using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using AOT;
using BepInEx;
using ImGuiNET;
using Microsoft.CodeAnalysis;
using UBImGui;
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
using UnityEngine;
using UnityEngine.Device;
using UnityEngine.EventSystems;
using UnityEngine.Rendering;
using UnityEngine.Rendering.RenderGraphModule;
using UnityEngine.Rendering.Universal;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: InternalsVisibleTo("UBImGui.Editor")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("UBImGui")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+71580a59ae1c24af71e2798d53a50e92c8c74e4d")]
[assembly: AssemblyProduct("UBImGui")]
[assembly: AssemblyTitle("UBImGui")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace ImGuiNET
{
	public delegate void Platform_CreateWindow(ImGuiViewportPtr vp);
	public delegate void Platform_DestroyWindow(ImGuiViewportPtr vp);
	public delegate void Platform_ShowWindow(ImGuiViewportPtr vp);
	public delegate void Platform_SetWindowPos(ImGuiViewportPtr vp, Vector2 pos);
	public unsafe delegate void Platform_GetWindowPos(ImGuiViewportPtr vp, Vector2* outPos);
	public delegate void Platform_SetWindowSize(ImGuiViewportPtr vp, Vector2 size);
	public unsafe delegate void Platform_GetWindowSize(ImGuiViewportPtr vp, Vector2* outSize);
	public delegate void Platform_SetWindowFocus(ImGuiViewportPtr vp);
	public delegate byte Platform_GetWindowFocus(ImGuiViewportPtr vp);
	public delegate byte Platform_GetWindowMinimized(ImGuiViewportPtr vp);
	public delegate void Platform_SetWindowTitle(ImGuiViewportPtr vp, IntPtr title);
	public struct ImColor
	{
		public Vector4 Value;
	}
	public struct ImColorPtr
	{
		public unsafe ImColor* NativePtr { get; }

		public unsafe ref Vector4 Value => ref Unsafe.AsRef<Vector4>((void*)(&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>((void*)(&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>((void*)(&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 ImVector 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 ImVector<ImDrawListPtr> CmdLists => new ImVector<ImDrawListPtr>(NativePtr->CmdLists);

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

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

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

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

		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 AddDrawList(ImDrawListPtr draw_list)
		{
			ImDrawList* nativePtr = draw_list.NativePtr;
			ImGuiNative.ImDrawData_AddDrawList(NativePtr, 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)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			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 ImDrawVert* _VtxWritePtr;

		public unsafe ushort* _IdxWritePtr;

		public ImVector _Path;

		public ImDrawCmdHeader _CmdHeader;

		public ImDrawListSplitter _Splitter;

		public ImVector _ClipRectStack;

		public ImVector _TextureIdStack;

		public float _FringeScale;

		public unsafe byte* _OwnerName;
	}
	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 ImDrawVertPtr _VtxWritePtr => new ImDrawVertPtr(NativePtr->_VtxWritePtr);

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

		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 ImVector<Vector4> _ClipRectStack => new ImVector<Vector4>(NativePtr->_ClipRectStack);

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

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

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

		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)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			ImGuiNative.ImDrawList_AddCircle(NativePtr, center, radius, col, num_segments, thickness);
		}

		public unsafe void AddCircleFilled(Vector2 center, float radius, uint col)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			ImGuiNative.ImDrawList_AddCircleFilled(NativePtr, center, radius, col, num_segments);
		}

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

		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 AddEllipse(Vector2 center, Vector2 radius, uint col)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			float rot = 0f;
			int num_segments = 0;
			float thickness = 1f;
			ImGuiNative.ImDrawList_AddEllipse(NativePtr, center, radius, col, rot, num_segments, thickness);
		}

		public unsafe void AddEllipse(Vector2 center, Vector2 radius, uint col, float rot)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			int num_segments = 0;
			float thickness = 1f;
			ImGuiNative.ImDrawList_AddEllipse(NativePtr, center, radius, col, rot, num_segments, thickness);
		}

		public unsafe void AddEllipse(Vector2 center, Vector2 radius, uint col, float rot, int num_segments)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			float thickness = 1f;
			ImGuiNative.ImDrawList_AddEllipse(NativePtr, center, radius, col, rot, num_segments, thickness);
		}

		public unsafe void AddEllipse(Vector2 center, Vector2 radius, uint col, float rot, int num_segments, float thickness)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			ImGuiNative.ImDrawList_AddEllipse(NativePtr, center, radius, col, rot, num_segments, thickness);
		}

		public unsafe void AddEllipseFilled(Vector2 center, Vector2 radius, uint col)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			float rot = 0f;
			int num_segments = 0;
			ImGuiNative.ImDrawList_AddEllipseFilled(NativePtr, center, radius, col, rot, num_segments);
		}

		public unsafe void AddEllipseFilled(Vector2 center, Vector2 radius, uint col, float rot)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			int num_segments = 0;
			ImGuiNative.ImDrawList_AddEllipseFilled(NativePtr, center, radius, col, rot, num_segments);
		}

		public unsafe void AddEllipseFilled(Vector2 center, Vector2 radius, uint col, float rot, int num_segments)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			ImGuiNative.ImDrawList_AddEllipseFilled(NativePtr, center, radius, col, rot, num_segments);
		}

		public unsafe void AddImage(IntPtr user_texture_id, Vector2 p_min, Vector2 p_max)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			Vector2 uv_min = default(Vector2);
			Vector2 uv_max = default(Vector2);
			((Vector2)(ref uv_max))..ctor(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)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			Vector2 uv_max = default(Vector2);
			((Vector2)(ref uv_max))..ctor(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)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			Vector2 uv = default(Vector2);
			Vector2 uv2 = default(Vector2);
			((Vector2)(ref uv2))..ctor(1f, 0f);
			Vector2 uv3 = default(Vector2);
			((Vector2)(ref uv3))..ctor(1f, 1f);
			Vector2 uv4 = default(Vector2);
			((Vector2)(ref uv4))..ctor(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)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			Vector2 uv2 = default(Vector2);
			((Vector2)(ref uv2))..ctor(1f, 0f);
			Vector2 uv3 = default(Vector2);
			((Vector2)(ref uv3))..ctor(1f, 1f);
			Vector2 uv4 = default(Vector2);
			((Vector2)(ref uv4))..ctor(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)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			Vector2 uv3 = default(Vector2);
			((Vector2)(ref uv3))..ctor(1f, 1f);
			Vector2 uv4 = default(Vector2);
			((Vector2)(ref uv4))..ctor(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)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			Vector2 uv4 = default(Vector2);
			((Vector2)(ref uv4))..ctor(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)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			float thickness = 1f;
			ImGuiNative.ImDrawList_AddLine(NativePtr, p1, p2, col, thickness);
		}

		public unsafe void AddLine(Vector2 p1, Vector2 p2, uint col, float thickness)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			ImGuiNative.ImDrawList_AddLine(NativePtr, p1, p2, col, thickness);
		}

		public unsafe void AddNgon(Vector2 center, float radius, uint col, int num_segments)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			ImGuiNative.ImDrawList_AddNgon(NativePtr, center, radius, col, num_segments, thickness);
		}

		public unsafe void AddNgonFilled(Vector2 center, float radius, uint col, int num_segments)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			ImGuiNative.ImDrawList_AddQuad(NativePtr, p1, p2, p3, p4, col, thickness);
		}

		public unsafe void AddQuadFilled(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, uint col)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			ImGuiNative.ImDrawList_AddQuadFilled(NativePtr, p1, p2, p3, p4, col);
		}

		public unsafe void AddRect(Vector2 p_min, Vector2 p_max, uint col)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			ImGuiNative.ImDrawList_AddRect(NativePtr, p_min, p_max, col, rounding, flags, thickness);
		}

		public unsafe void AddRectFilled(Vector2 p_min, Vector2 p_max, uint col)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			ImGuiNative.ImDrawList_AddRectFilledMultiColor(NativePtr, p_min, p_max, col_upr_left, col_upr_right, col_bot_right, col_bot_left);
		}

		public unsafe void AddText(Vector2 pos, uint col, ReadOnlySpan<char> text_begin)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			num = Encoding.UTF8.GetByteCount(text_begin);
			byte* ptr;
			if (num > 2048)
			{
				ptr = Util.Allocate(num + 1);
			}
			else
			{
				byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
				ptr = ptr2;
			}
			int utf = Util.GetUtf8(text_begin, ptr, num);
			ptr[utf] = 0;
			ImGuiNative.ImDrawList_AddText_Vec2(NativePtr, pos, col, ptr, ptr + num);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
		}

		public unsafe void AddText(Vector2 pos, uint col, string text_begin)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			num = Encoding.UTF8.GetByteCount(text_begin);
			byte* ptr;
			if (num > 2048)
			{
				ptr = Util.Allocate(num + 1);
			}
			else
			{
				byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
				ptr = ptr2;
			}
			int utf = Util.GetUtf8(text_begin, ptr, num);
			ptr[utf] = 0;
			ImGuiNative.ImDrawList_AddText_Vec2(NativePtr, pos, col, ptr, ptr + num);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
		}

		public unsafe void AddText(ImFontPtr font, float font_size, Vector2 pos, uint col, ReadOnlySpan<char> text_begin)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			ImFont* nativePtr = font.NativePtr;
			int num = 0;
			num = Encoding.UTF8.GetByteCount(text_begin);
			byte* ptr;
			if (num > 2048)
			{
				ptr = Util.Allocate(num + 1);
			}
			else
			{
				byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
				ptr = ptr2;
			}
			int utf = Util.GetUtf8(text_begin, ptr, num);
			ptr[utf] = 0;
			float wrap_width = 0f;
			Vector4* cpu_fine_clip_rect = null;
			ImGuiNative.ImDrawList_AddText_FontPtr(NativePtr, nativePtr, font_size, pos, col, ptr, ptr + num, wrap_width, cpu_fine_clip_rect);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
		}

		public unsafe void AddText(ImFontPtr font, float font_size, Vector2 pos, uint col, string text_begin)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			ImFont* nativePtr = font.NativePtr;
			int num = 0;
			num = Encoding.UTF8.GetByteCount(text_begin);
			byte* ptr;
			if (num > 2048)
			{
				ptr = Util.Allocate(num + 1);
			}
			else
			{
				byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
				ptr = ptr2;
			}
			int utf = Util.GetUtf8(text_begin, ptr, num);
			ptr[utf] = 0;
			float wrap_width = 0f;
			Vector4* cpu_fine_clip_rect = null;
			ImGuiNative.ImDrawList_AddText_FontPtr(NativePtr, nativePtr, font_size, pos, col, ptr, ptr + num, wrap_width, cpu_fine_clip_rect);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
		}

		public unsafe void AddText(ImFontPtr font, float font_size, Vector2 pos, uint col, ReadOnlySpan<char> text_begin, float wrap_width)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			ImFont* nativePtr = font.NativePtr;
			int num = 0;
			num = Encoding.UTF8.GetByteCount(text_begin);
			byte* ptr;
			if (num > 2048)
			{
				ptr = Util.Allocate(num + 1);
			}
			else
			{
				byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
				ptr = ptr2;
			}
			int utf = Util.GetUtf8(text_begin, ptr, num);
			ptr[utf] = 0;
			Vector4* cpu_fine_clip_rect = null;
			ImGuiNative.ImDrawList_AddText_FontPtr(NativePtr, nativePtr, font_size, pos, col, ptr, ptr + num, wrap_width, cpu_fine_clip_rect);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
		}

		public unsafe void AddText(ImFontPtr font, float font_size, Vector2 pos, uint col, string text_begin, float wrap_width)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			ImFont* nativePtr = font.NativePtr;
			int num = 0;
			num = Encoding.UTF8.GetByteCount(text_begin);
			byte* ptr;
			if (num > 2048)
			{
				ptr = Util.Allocate(num + 1);
			}
			else
			{
				byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
				ptr = ptr2;
			}
			int utf = Util.GetUtf8(text_begin, ptr, num);
			ptr[utf] = 0;
			Vector4* cpu_fine_clip_rect = null;
			ImGuiNative.ImDrawList_AddText_FontPtr(NativePtr, nativePtr, font_size, pos, col, ptr, ptr + num, wrap_width, cpu_fine_clip_rect);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
		}

		public unsafe void AddText(ImFontPtr font, float font_size, Vector2 pos, uint col, ReadOnlySpan<char> text_begin, float wrap_width, ref Vector4 cpu_fine_clip_rect)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			ImFont* nativePtr = font.NativePtr;
			int num = 0;
			num = Encoding.UTF8.GetByteCount(text_begin);
			byte* ptr;
			if (num > 2048)
			{
				ptr = Util.Allocate(num + 1);
			}
			else
			{
				byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
				ptr = ptr2;
			}
			int utf = Util.GetUtf8(text_begin, ptr, num);
			ptr[utf] = 0;
			fixed (Vector4* cpu_fine_clip_rect2 = &cpu_fine_clip_rect)
			{
				ImGuiNative.ImDrawList_AddText_FontPtr(NativePtr, nativePtr, font_size, pos, col, ptr, ptr + num, wrap_width, cpu_fine_clip_rect2);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
			}
		}

		public unsafe void AddText(ImFontPtr font, float font_size, Vector2 pos, uint col, string text_begin, float wrap_width, ref Vector4 cpu_fine_clip_rect)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			ImFont* nativePtr = font.NativePtr;
			int num = 0;
			num = Encoding.UTF8.GetByteCount(text_begin);
			byte* ptr;
			if (num > 2048)
			{
				ptr = Util.Allocate(num + 1);
			}
			else
			{
				byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
				ptr = ptr2;
			}
			int utf = Util.GetUtf8(text_begin, ptr, num);
			ptr[utf] = 0;
			fixed (Vector4* cpu_fine_clip_rect2 = &cpu_fine_clip_rect)
			{
				ImGuiNative.ImDrawList_AddText_FontPtr(NativePtr, nativePtr, font_size, pos, col, ptr, ptr + num, wrap_width, cpu_fine_clip_rect2);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
			}
		}

		public unsafe void AddTriangle(Vector2 p1, Vector2 p2, Vector2 p3, uint col)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			ImGuiNative.ImDrawList_AddTriangle(NativePtr, p1, p2, p3, col, thickness);
		}

		public unsafe void AddTriangleFilled(Vector2 p1, Vector2 p2, Vector2 p3, uint col)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			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()
		{
			ImDrawList* nativePtr = ImGuiNative.ImDrawList_CloneOutput(NativePtr);
			return new ImDrawListPtr(nativePtr);
		}

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

		public unsafe Vector2 GetClipRectMax()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			Vector2 result = default(Vector2);
			ImGuiNative.ImDrawList_GetClipRectMax(&result, NativePtr);
			return result;
		}

		public unsafe Vector2 GetClipRectMin()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			ImGuiNative.ImDrawList_PathArcToFast(NativePtr, center, radius, a_min_of_12, a_max_of_12);
		}

		public unsafe void PathBezierCubicCurveTo(Vector2 p2, Vector2 p3, Vector2 p4)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			ImGuiNative.ImDrawList_PathBezierCubicCurveTo(NativePtr, p2, p3, p4, num_segments);
		}

		public unsafe void PathBezierQuadraticCurveTo(Vector2 p2, Vector2 p3)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			int num_segments = 0;
			ImGuiNative.ImDrawList_PathBezierQuadraticCurveTo(NativePtr, p2, p3, num_segments);
		}

		public unsafe void PathBezierQuadraticCurveTo(Vector2 p2, Vector2 p3, int num_segments)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			ImGuiNative.ImDrawList_PathBezierQuadraticCurveTo(NativePtr, p2, p3, num_segments);
		}

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

		public unsafe void PathEllipticalArcTo(Vector2 center, Vector2 radius, float rot, float a_min, float a_max)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			int num_segments = 0;
			ImGuiNative.ImDrawList_PathEllipticalArcTo(NativePtr, center, radius, rot, a_min, a_max, num_segments);
		}

		public unsafe void PathEllipticalArcTo(Vector2 center, Vector2 radius, float rot, float a_min, float a_max, int num_segments)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			ImGuiNative.ImDrawList_PathEllipticalArcTo(NativePtr, center, radius, rot, a_min, a_max, num_segments);
		}

		public unsafe void PathFillConcave(uint col)
		{
			ImGuiNative.ImDrawList_PathFillConcave(NativePtr, col);
		}

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

		public unsafe void PathLineTo(Vector2 pos)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			ImGuiNative.ImDrawList_PathLineTo(NativePtr, pos);
		}

		public unsafe void PathLineToMergeDuplicate(Vector2 pos)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			ImGuiNative.ImDrawList_PathLineToMergeDuplicate(NativePtr, pos);
		}

		public unsafe void PathRect(Vector2 rect_min, Vector2 rect_max)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			ImGuiNative.ImDrawList_PrimRect(NativePtr, a, b, col);
		}

		public unsafe void PrimRectUV(Vector2 a, Vector2 b, Vector2 uv_a, Vector2 uv_b, uint col)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			ImGuiNative.ImDrawList_PrimWriteVtx(NativePtr, pos, uv, col);
		}

		public unsafe void PushClipRect(Vector2 clip_rect_min, Vector2 clip_rect_max)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			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);
		}
	}
	[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>((void*)(&NativePtr->pos));

		public unsafe ref Vector2 uv => ref Unsafe.AsRef<Vector2>((void*)(&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 short EllipsisCharCount;

		public float EllipsisWidth;

		public float EllipsisCharStep;

		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 short EllipsisCharCount => ref Unsafe.AsRef<short>(&NativePtr->EllipsisCharCount);

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

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

		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 Vector2 CalcTextSizeA(float size, float max_width, float wrap_width, ReadOnlySpan<char> text_begin)
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			num = Encoding.UTF8.GetByteCount(text_begin);
			byte* ptr;
			if (num > 2048)
			{
				ptr = Util.Allocate(num + 1);
			}
			else
			{
				byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
				ptr = ptr2;
			}
			int utf = Util.GetUtf8(text_begin, ptr, num);
			ptr[utf] = 0;
			byte** remaining = null;
			Vector2 result = default(Vector2);
			ImGuiNative.ImFont_CalcTextSizeA(&result, NativePtr, size, max_width, wrap_width, ptr, ptr + num, remaining);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return result;
		}

		public unsafe Vector2 CalcTextSizeA(float size, float max_width, float wrap_width, string text_begin)
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			num = Encoding.UTF8.GetByteCount(text_begin);
			byte* ptr;
			if (num > 2048)
			{
				ptr = Util.Allocate(num + 1);
			}
			else
			{
				byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
				ptr = ptr2;
			}
			int utf = Util.GetUtf8(text_begin, ptr, num);
			ptr[utf] = 0;
			byte** remaining = null;
			Vector2 result = default(Vector2);
			ImGuiNative.ImFont_CalcTextSizeA(&result, NativePtr, size, max_width, wrap_width, ptr, ptr + num, remaining);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return result;
		}

		public unsafe Vector2 CalcTextSizeA(float size, float max_width, float wrap_width, ReadOnlySpan<char> text_begin, ref byte* remaining)
		{
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			num = Encoding.UTF8.GetByteCount(text_begin);
			byte* ptr;
			if (num > 2048)
			{
				ptr = Util.Allocate(num + 1);
			}
			else
			{
				byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
				ptr = ptr2;
			}
			int utf = Util.GetUtf8(text_begin, ptr, num);
			ptr[utf] = 0;
			fixed (byte** remaining2 = &remaining)
			{
				Vector2 result = default(Vector2);
				ImGuiNative.ImFont_CalcTextSizeA(&result, NativePtr, size, max_width, wrap_width, ptr, ptr + num, remaining2);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				return result;
			}
		}

		public unsafe Vector2 CalcTextSizeA(float size, float max_width, float wrap_width, string text_begin, ref byte* remaining)
		{
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			num = Encoding.UTF8.GetByteCount(text_begin);
			byte* ptr;
			if (num > 2048)
			{
				ptr = Util.Allocate(num + 1);
			}
			else
			{
				byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
				ptr = ptr2;
			}
			int utf = Util.GetUtf8(text_begin, ptr, num);
			ptr[utf] = 0;
			fixed (byte** remaining2 = &remaining)
			{
				Vector2 result = default(Vector2);
				ImGuiNative.ImFont_CalcTextSizeA(&result, NativePtr, size, max_width, wrap_width, ptr, ptr + num, remaining2);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				return result;
			}
		}

		public unsafe string CalcWordWrapPositionA(float scale, ReadOnlySpan<char> text, float wrap_width)
		{
			int num = 0;
			byte* ptr;
			if (text != null)
			{
				num = Encoding.UTF8.GetByteCount(text);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(text, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte* ptr3 = ImGuiNative.ImFont_CalcWordWrapPositionA(NativePtr, scale, ptr, ptr + num, wrap_width);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return Util.StringFromPtr(ptr3);
		}

		public unsafe string CalcWordWrapPositionA(float scale, string text, float wrap_width)
		{
			int num = 0;
			byte* ptr;
			if (text != null)
			{
				num = Encoding.UTF8.GetByteCount(text);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(text, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte* ptr3 = ImGuiNative.ImFont_CalcWordWrapPositionA(NativePtr, scale, ptr, ptr + num, wrap_width);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return Util.StringFromPtr(ptr3);
		}

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

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

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

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

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

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

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

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

		public unsafe void RenderChar(ImDrawListPtr draw_list, float size, Vector2 pos, uint col, ushort c)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			ImDrawList* nativePtr = draw_list.NativePtr;
			ImGuiNative.ImFont_RenderChar(NativePtr, nativePtr, size, pos, col, c);
		}

		public unsafe void RenderText(ImDrawListPtr draw_list, float size, Vector2 pos, uint col, Vector4 clip_rect, ReadOnlySpan<char> text_begin)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			ImDrawList* nativePtr = draw_list.NativePtr;
			int num = 0;
			num = Encoding.UTF8.GetByteCount(text_begin);
			byte* ptr;
			if (num > 2048)
			{
				ptr = Util.Allocate(num + 1);
			}
			else
			{
				byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
				ptr = ptr2;
			}
			int utf = Util.GetUtf8(text_begin, ptr, num);
			ptr[utf] = 0;
			float wrap_width = 0f;
			byte cpu_fine_clip = 0;
			ImGuiNative.ImFont_RenderText(NativePtr, nativePtr, size, pos, col, clip_rect, ptr, ptr + num, wrap_width, cpu_fine_clip);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
		}

		public unsafe void RenderText(ImDrawListPtr draw_list, float size, Vector2 pos, uint col, Vector4 clip_rect, string text_begin)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			ImDrawList* nativePtr = draw_list.NativePtr;
			int num = 0;
			num = Encoding.UTF8.GetByteCount(text_begin);
			byte* ptr;
			if (num > 2048)
			{
				ptr = Util.Allocate(num + 1);
			}
			else
			{
				byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
				ptr = ptr2;
			}
			int utf = Util.GetUtf8(text_begin, ptr, num);
			ptr[utf] = 0;
			float wrap_width = 0f;
			byte cpu_fine_clip = 0;
			ImGuiNative.ImFont_RenderText(NativePtr, nativePtr, size, pos, col, clip_rect, ptr, ptr + num, wrap_width, cpu_fine_clip);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
		}

		public unsafe void RenderText(ImDrawListPtr draw_list, float size, Vector2 pos, uint col, Vector4 clip_rect, ReadOnlySpan<char> text_begin, float wrap_width)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			ImDrawList* nativePtr = draw_list.NativePtr;
			int num = 0;
			num = Encoding.UTF8.GetByteCount(text_begin);
			byte* ptr;
			if (num > 2048)
			{
				ptr = Util.Allocate(num + 1);
			}
			else
			{
				byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
				ptr = ptr2;
			}
			int utf = Util.GetUtf8(text_begin, ptr, num);
			ptr[utf] = 0;
			byte cpu_fine_clip = 0;
			ImGuiNative.ImFont_RenderText(NativePtr, nativePtr, size, pos, col, clip_rect, ptr, ptr + num, wrap_width, cpu_fine_clip);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
		}

		public unsafe void RenderText(ImDrawListPtr draw_list, float size, Vector2 pos, uint col, Vector4 clip_rect, string text_begin, float wrap_width)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			ImDrawList* nativePtr = draw_list.NativePtr;
			int num = 0;
			num = Encoding.UTF8.GetByteCount(text_begin);
			byte* ptr;
			if (num > 2048)
			{
				ptr = Util.Allocate(num + 1);
			}
			else
			{
				byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
				ptr = ptr2;
			}
			int utf = Util.GetUtf8(text_begin, ptr, num);
			ptr[utf] = 0;
			byte cpu_fine_clip = 0;
			ImGuiNative.ImFont_RenderText(NativePtr, nativePtr, size, pos, col, clip_rect, ptr, ptr + num, wrap_width, cpu_fine_clip);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
		}

		public unsafe void RenderText(ImDrawListPtr draw_list, float size, Vector2 pos, uint col, Vector4 clip_rect, ReadOnlySpan<char> text_begin, float wrap_width, bool cpu_fine_clip)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			ImDrawList* nativePtr = draw_list.NativePtr;
			int num = 0;
			num = Encoding.UTF8.GetByteCount(text_begin);
			byte* ptr;
			if (num > 2048)
			{
				ptr = Util.Allocate(num + 1);
			}
			else
			{
				byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
				ptr = ptr2;
			}
			int utf = Util.GetUtf8(text_begin, ptr, num);
			ptr[utf] = 0;
			byte cpu_fine_clip2 = (byte)(cpu_fine_clip ? 1 : 0);
			ImGuiNative.ImFont_RenderText(NativePtr, nativePtr, size, pos, col, clip_rect, ptr, ptr + num, wrap_width, cpu_fine_clip2);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
		}

		public unsafe void RenderText(ImDrawListPtr draw_list, float size, Vector2 pos, uint col, Vector4 clip_rect, string text_begin, float wrap_width, bool cpu_fine_clip)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			ImDrawList* nativePtr = draw_list.NativePtr;
			int num = 0;
			num = Encoding.UTF8.GetByteCount(text_begin);
			byte* ptr;
			if (num > 2048)
			{
				ptr = Util.Allocate(num + 1);
			}
			else
			{
				byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
				ptr = ptr2;
			}
			int utf = Util.GetUtf8(text_begin, ptr, num);
			ptr[utf] = 0;
			byte cpu_fine_clip2 = (byte)(cpu_fine_clip ? 1 : 0);
			ImGuiNative.ImFont_RenderText(NativePtr, nativePtr, size, pos, col, clip_rect, ptr, ptr + num, wrap_width, cpu_fine_clip2);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
		}

		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 unsafe void* UserData;

		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 IntPtr UserData
		{
			get
			{
				return (IntPtr)NativePtr->UserData;
			}
			set
			{
				NativePtr->UserData = (void*)value;
			}
		}

		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>((void*)(&NativePtr->TexUvScale));

		public unsafe ref Vector2 TexUvWhitePixel => ref Unsafe.AsRef<Vector2>((void*)(&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)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			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;
			ImFont* nativePtr2 = ImGuiNative.ImFontAtlas_AddFont(NativePtr, nativePtr);
			return new ImFontPtr(nativePtr2);
		}

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

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

		public unsafe ImFontPtr AddFontFromFileTTF(ReadOnlySpan<char> filename, float size_pixels)
		{
			int num = 0;
			byte* ptr;
			if (filename != null)
			{
				num = Encoding.UTF8.GetByteCount(filename);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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)
		{
			int num = 0;
			byte* ptr;
			if (filename != null)
			{
				num = Encoding.UTF8.GetByteCount(filename);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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(ReadOnlySpan<char> filename, float size_pixels, ImFontConfigPtr font_cfg)
		{
			int num = 0;
			byte* ptr;
			if (filename != null)
			{
				num = Encoding.UTF8.GetByteCount(filename);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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)
		{
			int num = 0;
			byte* ptr;
			if (filename != null)
			{
				num = Encoding.UTF8.GetByteCount(filename);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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(ReadOnlySpan<char> filename, float size_pixels, ImFontConfigPtr font_cfg, IntPtr glyph_ranges)
		{
			int num = 0;
			byte* ptr;
			if (filename != null)
			{
				num = Encoding.UTF8.GetByteCount(filename);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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(ReadOnlySpan<char> 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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)
		{
			int num = 0;
			byte* ptr;
			if (compressed_font_data_base85 != null)
			{
				num = Encoding.UTF8.GetByteCount(compressed_font_data_base85);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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(ReadOnlySpan<char> 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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)
		{
			int num = 0;
			byte* ptr;
			if (compressed_font_data_base85 != null)
			{
				num = Encoding.UTF8.GetByteCount(compressed_font_data_base85);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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(ReadOnlySpan<char> 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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_data_size, float size_pixels)
		{
			void* compressed_font_data2 = compressed_font_data.ToPointer();
			ImFontConfig* font_cfg = null;
			ushort* glyph_ranges = null;
			ImFont* nativePtr = ImGuiNative.ImFontAtlas_AddFontFromMemoryCompressedTTF(NativePtr, compressed_font_data2, compressed_font_data_size, size_pixels, font_cfg, glyph_ranges);
			return new ImFontPtr(nativePtr);
		}

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

		public unsafe ImFontPtr AddFontFromMemoryCompressedTTF(IntPtr compressed_font_data, int compressed_font_data_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();
			ImFont* nativePtr2 = ImGuiNative.ImFontAtlas_AddFontFromMemoryCompressedTTF(NativePtr, compressed_font_data2, compressed_font_data_size, size_pixels, nativePtr, glyph_ranges2);
			return new ImFontPtr(nativePtr2);
		}

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

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

		public unsafe ImFontPtr AddFontFromMemoryTTF(IntPtr font_data, int font_data_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();
			ImFont* nativePtr2 = ImGuiNative.ImFontAtlas_AddFontFromMemoryTTF(NativePtr, font_data2, font_data_size, size_pixels, nativePtr, glyph_ranges2);
			return new ImFontPtr(nativePtr2);
		}

		public unsafe bool Build()
		{
			byte b = ImGuiNative.ImFontAtlas_Build(NativePtr);
			return b != 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)
		{
			ImFontAtlasCustomRect* nativePtr = ImGuiNative.ImFontAtlas_GetCustomRectByIndex(NativePtr, index);
			return new ImFontAtlasCustomRectPtr(nativePtr);
		}

		public unsafe IntPtr GetGlyphRangesChineseFull()
		{
			ushort* ptr = ImGuiNative.ImFontAtlas_GetGlyphRangesChineseFull(NativePtr);
			return (IntPtr)ptr;
		}

		public unsafe IntPtr GetGlyphRangesChineseSimplifiedCommon()
		{
			ushort* ptr = ImGuiNative.ImFontAtlas_GetGlyphRangesChineseSimplifiedCommon(NativePtr);
			return (IntPtr)ptr;
		}

		public unsafe IntPtr GetGlyphRangesCyrillic()
		{
			ushort* ptr = ImGuiNative.ImFontAtlas_GetGlyphRangesCyrillic(NativePtr);
			return (IntPtr)ptr;
		}

		public unsafe IntPtr GetGlyphRangesDefault()
		{
			ushort* ptr = ImGuiNative.ImFontAtlas_GetGlyphRangesDefault(NativePtr);
			return (IntPtr)ptr;
		}

		public unsafe IntPtr GetGlyphRangesGreek()
		{
			ushort* ptr = ImGuiNative.ImFontAtlas_GetGlyphRangesGreek(NativePtr);
			return (IntPtr)ptr;
		}

		public unsafe IntPtr GetGlyphRangesJapanese()
		{
			ushort* ptr = ImGuiNative.ImFontAtlas_GetGlyphRangesJapanese(NativePtr);
			return (IntPtr)ptr;
		}

		public unsafe IntPtr GetGlyphRangesKorean()
		{
			ushort* ptr = ImGuiNative.ImFontAtlas_GetGlyphRangesKorean(NativePtr);
			return (IntPtr)ptr;
		}

		public unsafe IntPtr GetGlyphRangesThai()
		{
			ushort* ptr = ImGuiNative.ImFontAtlas_GetGlyphRangesThai(NativePtr);
			return (IntPtr)ptr;
		}

		public unsafe IntPtr GetGlyphRangesVietnamese()
		{
			ushort* ptr = ImGuiNative.ImFontAtlas_GetGlyphRangesVietnamese(NativePtr);
			return (IntPtr)ptr;
		}

		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)
						{
							byte b = ImGuiNative.ImFontAtlas_GetMouseCursorTexData(NativePtr, cursor, out_offset2, out_size2, out_uv_border2, out_uv_fill2);
							return b != 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()
		{
			byte b = ImGuiNative.ImFontAtlas_IsBuilt(NativePtr);
			return b != 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>((void*)(&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()
		{
			byte b = ImGuiNative.ImFontAtlasCustomRect_IsPacked(NativePtr);
			return b != 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 float RasterizerDensity;

		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>((void*)(&NativePtr->GlyphExtraSpacing));

		public unsafe ref Vector2 GlyphOffset => ref Unsafe.AsRef<Vector2>((void*)(&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 float RasterizerDensity => ref Unsafe.AsRef<float>(&NativePtr->RasterizerDensity);

		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(ReadOnlySpan<char> text)
		{
			int num = 0;
			byte* ptr;
			if (text != null)
			{
				num = Encoding.UTF8.GetByteCount(text);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(text, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			ImGuiNative.ImFontGlyphRangesBuilder_AddText(NativePtr, ptr, ptr + num);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
		}

		public unsafe void AddText(string text)
		{
			int num = 0;
			byte* ptr;
			if (text != null)
			{
				num = Encoding.UTF8.GetByteCount(text);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(text, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			ImGuiNative.ImFontGlyphRangesBuilder_AddText(NativePtr, ptr, ptr + num);
			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)
		{
			byte b = ImGuiNative.ImFontGlyphRangesBuilder_GetBit(NativePtr, n);
			return b != 0;
		}

		public unsafe void SetBit(uint n)
		{
			ImGuiNative.ImFontGlyphRangesBuilder_SetBit(NativePtr, n);
		}
	}
	public static class ImGui
	{
		public static event Action Layout
		{
			add
			{
				ImGuiBehaviour.Initialize();
				ImGuiController.CurrentController.Layout += value;
			}
			remove
			{
				if (ImGuiController.CurrentController != null)
				{
					ImGuiController.CurrentController.Layout -= value;
				}
			}
		}

		public unsafe static ImGuiPayloadPtr AcceptDragDropPayload(ReadOnlySpan<char> type)
		{
			int num = 0;
			byte* ptr;
			if (type != null)
			{
				num = Encoding.UTF8.GetByteCount(type);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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)
		{
			int num = 0;
			byte* ptr;
			if (type != null)
			{
				num = Encoding.UTF8.GetByteCount(type);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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(ReadOnlySpan<char> type, ImGuiDragDropFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (type != null)
			{
				num = Encoding.UTF8.GetByteCount(type);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 unsafe static ImGuiPayloadPtr AcceptDragDropPayload(string type, ImGuiDragDropFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (type != null)
			{
				num = Encoding.UTF8.GetByteCount(type);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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(ReadOnlySpan<char> str_id, ImGuiDir dir)
		{
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igArrowButton(ptr, dir);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igArrowButton(ptr, dir);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

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

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

		public unsafe static bool Begin(ReadOnlySpan<char> name, ref bool p_open)
		{
			int num = 0;
			byte* ptr;
			if (name != null)
			{
				num = Encoding.UTF8.GetByteCount(name);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b2 = ImGuiNative.igBegin(ptr, p_open2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			p_open = b != 0;
			return b2 != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b2 = ImGuiNative.igBegin(ptr, p_open2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			p_open = b != 0;
			return b2 != 0;
		}

		public unsafe static bool Begin(ReadOnlySpan<char> name, ref bool p_open, ImGuiWindowFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (name != null)
			{
				num = Encoding.UTF8.GetByteCount(name);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b2 = ImGuiNative.igBegin(ptr, p_open2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			p_open = b != 0;
			return b2 != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b2 = ImGuiNative.igBegin(ptr, p_open2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			p_open = b != 0;
			return b2 != 0;
		}

		public unsafe static bool BeginChild(ReadOnlySpan<char> str_id)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			Vector2 size = default(Vector2);
			ImGuiChildFlags child_flags = ImGuiChildFlags.None;
			ImGuiWindowFlags window_flags = ImGuiWindowFlags.None;
			byte b = ImGuiNative.igBeginChild_Str(ptr, size, child_flags, window_flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool BeginChild(string str_id)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			Vector2 size = default(Vector2);
			ImGuiChildFlags child_flags = ImGuiChildFlags.None;
			ImGuiWindowFlags window_flags = ImGuiWindowFlags.None;
			byte b = ImGuiNative.igBeginChild_Str(ptr, size, child_flags, window_flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool BeginChild(ReadOnlySpan<char> str_id, Vector2 size)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			ImGuiChildFlags child_flags = ImGuiChildFlags.None;
			ImGuiWindowFlags window_flags = ImGuiWindowFlags.None;
			byte b = ImGuiNative.igBeginChild_Str(ptr, size, child_flags, window_flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool BeginChild(string str_id, Vector2 size)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			ImGuiChildFlags child_flags = ImGuiChildFlags.None;
			ImGuiWindowFlags window_flags = ImGuiWindowFlags.None;
			byte b = ImGuiNative.igBeginChild_Str(ptr, size, child_flags, window_flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool BeginChild(ReadOnlySpan<char> str_id, Vector2 size, ImGuiChildFlags child_flags)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			ImGuiWindowFlags window_flags = ImGuiWindowFlags.None;
			byte b = ImGuiNative.igBeginChild_Str(ptr, size, child_flags, window_flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool BeginChild(string str_id, Vector2 size, ImGuiChildFlags child_flags)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			ImGuiWindowFlags window_flags = ImGuiWindowFlags.None;
			byte b = ImGuiNative.igBeginChild_Str(ptr, size, child_flags, window_flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool BeginChild(ReadOnlySpan<char> str_id, Vector2 size, ImGuiChildFlags child_flags, ImGuiWindowFlags window_flags)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igBeginChild_Str(ptr, size, child_flags, window_flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool BeginChild(string str_id, Vector2 size, ImGuiChildFlags child_flags, ImGuiWindowFlags window_flags)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igBeginChild_Str(ptr, size, child_flags, window_flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public static bool BeginChild(uint id)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			Vector2 size = default(Vector2);
			ImGuiChildFlags child_flags = ImGuiChildFlags.None;
			ImGuiWindowFlags window_flags = ImGuiWindowFlags.None;
			byte b = ImGuiNative.igBeginChild_ID(id, size, child_flags, window_flags);
			return b != 0;
		}

		public static bool BeginChild(uint id, Vector2 size)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			ImGuiChildFlags child_flags = ImGuiChildFlags.None;
			ImGuiWindowFlags window_flags = ImGuiWindowFlags.None;
			byte b = ImGuiNative.igBeginChild_ID(id, size, child_flags, window_flags);
			return b != 0;
		}

		public static bool BeginChild(uint id, Vector2 size, ImGuiChildFlags child_flags)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			ImGuiWindowFlags window_flags = ImGuiWindowFlags.None;
			byte b = ImGuiNative.igBeginChild_ID(id, size, child_flags, window_flags);
			return b != 0;
		}

		public static bool BeginChild(uint id, Vector2 size, ImGuiChildFlags child_flags, ImGuiWindowFlags window_flags)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			byte b = ImGuiNative.igBeginChild_ID(id, size, child_flags, window_flags);
			return b != 0;
		}

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

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

		public unsafe static bool BeginCombo(ReadOnlySpan<char> label, ReadOnlySpan<char> preview_value, ImGuiComboFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (preview_value != null)
			{
				num2 = Encoding.UTF8.GetByteCount(preview_value);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(preview_value, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			byte b = ImGuiNative.igBeginCombo(ptr, ptr3, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr3);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (preview_value != null)
			{
				num2 = Encoding.UTF8.GetByteCount(preview_value);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(preview_value, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			byte b = ImGuiNative.igBeginCombo(ptr, ptr3, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr3);
			}
			return b != 0;
		}

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

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

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

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

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

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

		public static bool BeginItemTooltip()
		{
			byte b = ImGuiNative.igBeginItemTooltip();
			return b != 0;
		}

		public unsafe static bool BeginListBox(ReadOnlySpan<char> label)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igBeginListBox(ptr, default(Vector2));
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool BeginListBox(string label)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igBeginListBox(ptr, default(Vector2));
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool BeginListBox(ReadOnlySpan<char> label, Vector2 size)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igBeginListBox(ptr, size);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool BeginListBox(string label, Vector2 size)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igBeginListBox(ptr, size);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

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

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

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

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

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

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

		public unsafe static ImGuiMultiSelectIOPtr BeginMultiSelect(ImGuiMultiSelectFlags flags)
		{
			int selection_size = -1;
			int items_count = -1;
			ImGuiMultiSelectIO* nativePtr = ImGuiNative.igBeginMultiSelect(flags, selection_size, items_count);
			return new ImGuiMultiSelectIOPtr(nativePtr);
		}

		public unsafe static ImGuiMultiSelectIOPtr BeginMultiSelect(ImGuiMultiSelectFlags flags, int selection_size)
		{
			int items_count = -1;
			ImGuiMultiSelectIO* nativePtr = ImGuiNative.igBeginMultiSelect(flags, selection_size, items_count);
			return new ImGuiMultiSelectIOPtr(nativePtr);
		}

		public unsafe static ImGuiMultiSelectIOPtr BeginMultiSelect(ImGuiMultiSelectFlags flags, int selection_size, int items_count)
		{
			ImGuiMultiSelectIO* nativePtr = ImGuiNative.igBeginMultiSelect(flags, selection_size, items_count);
			return new ImGuiMultiSelectIOPtr(nativePtr);
		}

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

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

		public unsafe static bool BeginPopup(ReadOnlySpan<char> str_id, ImGuiWindowFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igBeginPopup(ptr, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igBeginPopup(ptr, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

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

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

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

		public unsafe static bool BeginPopupContextItem(ReadOnlySpan<char> str_id, ImGuiPopupFlags popup_flags)
		{
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igBeginPopupContextItem(ptr, popup_flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igBeginPopupContextItem(ptr, popup_flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

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

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

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

		public unsafe static bool BeginPopupContextVoid(ReadOnlySpan<char> str_id, ImGuiPopupFlags popup_flags)
		{
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igBeginPopupContextVoid(ptr, popup_flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igBeginPopupContextVoid(ptr, popup_flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

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

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

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

		public unsafe static bool BeginPopupContextWindow(ReadOnlySpan<char> str_id, ImGuiPopupFlags popup_flags)
		{
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igBeginPopupContextWindow(ptr, popup_flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igBeginPopupContextWindow(ptr, popup_flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

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

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

		public unsafe static bool BeginPopupModal(ReadOnlySpan<char> name, ref bool p_open)
		{
			int num = 0;
			byte* ptr;
			if (name != null)
			{
				num = Encoding.UTF8.GetByteCount(name);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b2 = ImGuiNative.igBeginPopupModal(ptr, p_open2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			p_open = b != 0;
			return b2 != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b2 = ImGuiNative.igBeginPopupModal(ptr, p_open2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			p_open = b != 0;
			return b2 != 0;
		}

		public unsafe static bool BeginPopupModal(ReadOnlySpan<char> name, ref bool p_open, ImGuiWindowFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (name != null)
			{
				num = Encoding.UTF8.GetByteCount(name);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b2 = ImGuiNative.igBeginPopupModal(ptr, p_open2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			p_open = b != 0;
			return b2 != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b2 = ImGuiNative.igBeginPopupModal(ptr, p_open2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			p_open = b != 0;
			return b2 != 0;
		}

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

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

		public unsafe static bool BeginTabBar(ReadOnlySpan<char> str_id, ImGuiTabBarFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igBeginTabBar(ptr, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igBeginTabBar(ptr, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

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

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

		public unsafe static bool BeginTabItem(ReadOnlySpan<char> label, ref bool p_open)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b2 = ImGuiNative.igBeginTabItem(ptr, p_open2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			p_open = b != 0;
			return b2 != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b2 = ImGuiNative.igBeginTabItem(ptr, p_open2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			p_open = b != 0;
			return b2 != 0;
		}

		public unsafe static bool BeginTabItem(ReadOnlySpan<char> label, ref bool p_open, ImGuiTabItemFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b2 = ImGuiNative.igBeginTabItem(ptr, p_open2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			p_open = b != 0;
			return b2 != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b2 = ImGuiNative.igBeginTabItem(ptr, p_open2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			p_open = b != 0;
			return b2 != 0;
		}

		public unsafe static bool BeginTable(ReadOnlySpan<char> str_id, int columns)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igBeginTable(ptr, columns, flags, outer_size, inner_width);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool BeginTable(string str_id, int columns)
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igBeginTable(ptr, columns, flags, outer_size, inner_width);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool BeginTable(ReadOnlySpan<char> str_id, int columns, ImGuiTableFlags flags)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			Vector2 outer_size = default(Vector2);
			float inner_width = 0f;
			byte b = ImGuiNative.igBeginTable(ptr, columns, flags, outer_size, inner_width);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool BeginTable(string str_id, int columns, ImGuiTableFlags flags)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			Vector2 outer_size = default(Vector2);
			float inner_width = 0f;
			byte b = ImGuiNative.igBeginTable(ptr, columns, flags, outer_size, inner_width);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool BeginTable(ReadOnlySpan<char> str_id, int columns, ImGuiTableFlags flags, Vector2 outer_size)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			float inner_width = 0f;
			byte b = ImGuiNative.igBeginTable(ptr, columns, flags, outer_size, inner_width);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool BeginTable(string str_id, int columns, ImGuiTableFlags flags, Vector2 outer_size)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			float inner_width = 0f;
			byte b = ImGuiNative.igBeginTable(ptr, columns, flags, outer_size, inner_width);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool BeginTable(ReadOnlySpan<char> str_id, int columns, ImGuiTableFlags flags, Vector2 outer_size, float inner_width)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igBeginTable(ptr, columns, flags, outer_size, inner_width);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool BeginTable(string str_id, int columns, ImGuiTableFlags flags, Vector2 outer_size, float inner_width)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igBeginTable(ptr, columns, flags, outer_size, inner_width);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public static bool BeginTooltip()
		{
			byte b = ImGuiNative.igBeginTooltip();
			return b != 0;
		}

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

		public unsafe static void BulletText(ReadOnlySpan<char> fmt)
		{
			int num = 0;
			byte* ptr;
			if (fmt != null)
			{
				num = Encoding.UTF8.GetByteCount(fmt);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 void BulletText(string fmt)
		{
			int num = 0;
			byte* ptr;
			if (fmt != null)
			{
				num = Encoding.UTF8.GetByteCount(fmt);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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(ReadOnlySpan<char> label)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igButton(ptr, default(Vector2));
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool Button(string label)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igButton(ptr, default(Vector2));
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool Button(ReadOnlySpan<char> label, Vector2 size)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igButton(ptr, size);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool Button(string label, Vector2 size)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igButton(ptr, size);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

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

		public unsafe static Vector2 CalcTextSize(ReadOnlySpan<char> text)
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (text != null)
			{
				num = Encoding.UTF8.GetByteCount(text);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(text, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte hide_text_after_double_hash = 0;
			float wrap_width = -1f;
			Vector2 result = default(Vector2);
			ImGuiNative.igCalcTextSize(&result, ptr, ptr + num, hide_text_after_double_hash, wrap_width);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return result;
		}

		public unsafe static Vector2 CalcTextSize(string text)
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (text != null)
			{
				num = Encoding.UTF8.GetByteCount(text);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(text, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte hide_text_after_double_hash = 0;
			float wrap_width = -1f;
			Vector2 result = default(Vector2);
			ImGuiNative.igCalcTextSize(&result, ptr, ptr + num, hide_text_after_double_hash, wrap_width);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return result;
		}

		public unsafe static Vector2 CalcTextSize(ReadOnlySpan<char> text, bool hide_text_after_double_hash)
		{
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (text != null)
			{
				num = Encoding.UTF8.GetByteCount(text);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(text, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte hide_text_after_double_hash2 = (byte)(hide_text_after_double_hash ? 1 : 0);
			float wrap_width = -1f;
			Vector2 result = default(Vector2);
			ImGuiNative.igCalcTextSize(&result, ptr, ptr + num, hide_text_after_double_hash2, wrap_width);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return result;
		}

		public unsafe static Vector2 CalcTextSize(string text, bool hide_text_after_double_hash)
		{
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (text != null)
			{
				num = Encoding.UTF8.GetByteCount(text);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(text, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte hide_text_after_double_hash2 = (byte)(hide_text_after_double_hash ? 1 : 0);
			float wrap_width = -1f;
			Vector2 result = default(Vector2);
			ImGuiNative.igCalcTextSize(&result, ptr, ptr + num, hide_text_after_double_hash2, wrap_width);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return result;
		}

		public unsafe static Vector2 CalcTextSize(ReadOnlySpan<char> text, bool hide_text_after_double_hash, float wrap_width)
		{
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (text != null)
			{
				num = Encoding.UTF8.GetByteCount(text);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(text, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte hide_text_after_double_hash2 = (byte)(hide_text_after_double_hash ? 1 : 0);
			Vector2 result = default(Vector2);
			ImGuiNative.igCalcTextSize(&result, ptr, ptr + num, hide_text_after_double_hash2, wrap_width);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return result;
		}

		public unsafe static Vector2 CalcTextSize(string text, bool hide_text_after_double_hash, float wrap_width)
		{
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (text != null)
			{
				num = Encoding.UTF8.GetByteCount(text);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(text, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte hide_text_after_double_hash2 = (byte)(hide_text_after_double_hash ? 1 : 0);
			Vector2 result = default(Vector2);
			ImGuiNative.igCalcTextSize(&result, ptr, ptr + num, hide_text_after_double_hash2, wrap_width);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return result;
		}

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

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

		public unsafe static bool CheckboxFlags(ReadOnlySpan<char> label, ref int flags, int flags_value)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			fixed (int* flags2 = &flags)
			{
				byte b = ImGuiNative.igCheckboxFlags_IntPtr(ptr, flags2, flags_value);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			fixed (int* flags2 = &flags)
			{
				byte b = ImGuiNative.igCheckboxFlags_IntPtr(ptr, flags2, flags_value);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				return b != 0;
			}
		}

		public unsafe static bool CheckboxFlags(ReadOnlySpan<char> label, ref uint flags, uint flags_value)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			fixed (uint* flags2 = &flags)
			{
				byte b = ImGuiNative.igCheckboxFlags_UintPtr(ptr, flags2, flags_value);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			fixed (uint* flags2 = &flags)
			{
				byte b = ImGuiNative.igCheckboxFlags_UintPtr(ptr, flags2, flags_value);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				return b != 0;
			}
		}

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

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

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

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

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

		public unsafe static bool CollapsingHeader(ReadOnlySpan<char> label, ref bool p_visible)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b2 = ImGuiNative.igCollapsingHeader_BoolPtr(ptr, p_visible2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			p_visible = b != 0;
			return b2 != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b2 = ImGuiNative.igCollapsingHeader_BoolPtr(ptr, p_visible2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			p_visible = b != 0;
			return b2 != 0;
		}

		public unsafe static bool CollapsingHeader(ReadOnlySpan<char> label, ref bool p_visible, ImGuiTreeNodeFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b2 = ImGuiNative.igCollapsingHeader_BoolPtr(ptr, p_visible2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			p_visible = b != 0;
			return b2 != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b2 = ImGuiNative.igCollapsingHeader_BoolPtr(ptr, p_visible2, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			p_visible = b != 0;
			return b2 != 0;
		}

		public unsafe static bool ColorButton(ReadOnlySpan<char> desc_id, Vector4 col)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (desc_id != null)
			{
				num = Encoding.UTF8.GetByteCount(desc_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(desc_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			ImGuiColorEditFlags flags = ImGuiColorEditFlags.None;
			byte b = ImGuiNative.igColorButton(ptr, col, flags, default(Vector2));
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool ColorButton(string desc_id, Vector4 col)
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (desc_id != null)
			{
				num = Encoding.UTF8.GetByteCount(desc_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(desc_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			ImGuiColorEditFlags flags = ImGuiColorEditFlags.None;
			byte b = ImGuiNative.igColorButton(ptr, col, flags, default(Vector2));
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool ColorButton(ReadOnlySpan<char> desc_id, Vector4 col, ImGuiColorEditFlags flags)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (desc_id != null)
			{
				num = Encoding.UTF8.GetByteCount(desc_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(desc_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igColorButton(ptr, col, flags, default(Vector2));
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool ColorButton(string desc_id, Vector4 col, ImGuiColorEditFlags flags)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (desc_id != null)
			{
				num = Encoding.UTF8.GetByteCount(desc_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(desc_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igColorButton(ptr, col, flags, default(Vector2));
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool ColorButton(ReadOnlySpan<char> desc_id, Vector4 col, ImGuiColorEditFlags flags, Vector2 size)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (desc_id != null)
			{
				num = Encoding.UTF8.GetByteCount(desc_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(desc_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igColorButton(ptr, col, flags, size);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool ColorButton(string desc_id, Vector4 col, ImGuiColorEditFlags flags, Vector2 size)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (desc_id != null)
			{
				num = Encoding.UTF8.GetByteCount(desc_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(desc_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igColorButton(ptr, col, flags, size);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public static uint ColorConvertFloat4ToU32(Vector4 @in)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			Vector4 result = default(Vector4);
			ImGuiNative.igColorConvertU32ToFloat4(&result, @in);
			return result;
		}

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

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

		public unsafe static bool ColorEdit3(ReadOnlySpan<char> label, ref Vector3 col, ImGuiColorEditFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			fixed (Vector3* col2 = &col)
			{
				byte b = ImGuiNative.igColorEdit3(ptr, col2, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			fixed (Vector3* col2 = &col)
			{
				byte b = ImGuiNative.igColorEdit3(ptr, col2, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				return b != 0;
			}
		}

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

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

		public unsafe static bool ColorEdit4(ReadOnlySpan<char> label, ref Vector4 col, ImGuiColorEditFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			fixed (Vector4* col2 = &col)
			{
				byte b = ImGuiNative.igColorEdit4(ptr, col2, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			fixed (Vector4* col2 = &col)
			{
				byte b = ImGuiNative.igColorEdit4(ptr, col2, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				return b != 0;
			}
		}

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

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

		public unsafe static bool ColorPicker3(ReadOnlySpan<char> label, ref Vector3 col, ImGuiColorEditFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			fixed (Vector3* col2 = &col)
			{
				byte b = ImGuiNative.igColorPicker3(ptr, col2, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			fixed (Vector3* col2 = &col)
			{
				byte b = ImGuiNative.igColorPicker3(ptr, col2, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				return b != 0;
			}
		}

		public unsafe static bool ColorPicker4(ReadOnlySpan<char> label, ref Vector4 col)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igColorPicker4(ptr, col2, flags, ref_col);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				return b != 0;
			}
		}

		public unsafe static bool ColorPicker4(string label, ref Vector4 col)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igColorPicker4(ptr, col2, flags, ref_col);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				return b != 0;
			}
		}

		public unsafe static bool ColorPicker4(ReadOnlySpan<char> label, ref Vector4 col, ImGuiColorEditFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			float* ref_col = null;
			fixed (Vector4* col2 = &col)
			{
				byte b = ImGuiNative.igColorPicker4(ptr, col2, flags, ref_col);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			float* ref_col = null;
			fixed (Vector4* col2 = &col)
			{
				byte b = ImGuiNative.igColorPicker4(ptr, col2, flags, ref_col);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				return b != 0;
			}
		}

		public unsafe static bool ColorPicker4(ReadOnlySpan<char> label, ref Vector4 col, ImGuiColorEditFlags flags, ref float ref_col)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			fixed (Vector4* col2 = &col)
			{
				fixed (float* ref_col2 = &ref_col)
				{
					byte b = ImGuiNative.igColorPicker4(ptr, col2, flags, ref_col2);
					if (num > 2048)
					{
						Util.Free(ptr);
					}
					return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			fixed (Vector4* col2 = &col)
			{
				fixed (float* ref_col2 = &ref_col)
				{
					byte b = ImGuiNative.igColorPicker4(ptr, col2, flags, ref_col2);
					if (num > 2048)
					{
						Util.Free(ptr);
					}
					return b != 0;
				}
			}
		}

		public unsafe static void Columns()
		{
			int count = 1;
			byte* id = null;
			byte border = 1;
			ImGuiNative.igColumns(count, 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, ReadOnlySpan<char> id)
		{
			int num = 0;
			byte* ptr;
			if (id != null)
			{
				num = Encoding.UTF8.GetByteCount(id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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)
		{
			int num = 0;
			byte* ptr;
			if (id != null)
			{
				num = Encoding.UTF8.GetByteCount(id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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, ReadOnlySpan<char> id, bool border)
		{
			int num = 0;
			byte* ptr;
			if (id != null)
			{
				num = Encoding.UTF8.GetByteCount(id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 void Columns(int count, string id, bool border)
		{
			int num = 0;
			byte* ptr;
			if (id != null)
			{
				num = Encoding.UTF8.GetByteCount(id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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(ReadOnlySpan<char> label, ref int current_item, string[] items, int items_count)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int* ptr3 = stackalloc int[items.Length];
			int num2 = 0;
			for (int i = 0; i < items.Length; i++)
			{
				string s = items[i];
				ptr3[i] = Encoding.UTF8.GetByteCount(s);
				num2 += ptr3[i] + 1;
			}
			byte* ptr4 = stackalloc byte[(int)(uint)num2];
			int num3 = 0;
			for (int j = 0; j < items.Length; j++)
			{
				string s2 = items[j];
				num3 += Util.GetUtf8(s2, ptr4 + num3, ptr3[j]);
				ptr4[num3++] = 0;
			}
			byte** ptr5 = stackalloc byte*[items.Length];
			num3 = 0;
			for (int k = 0; k < items.Length; k++)
			{
				ptr5[k] = ptr4 + num3;
				num3 += ptr3[k] + 1;
			}
			int popup_max_height_in_items = -1;
			fixed (int* current_item2 = &current_item)
			{
				byte b = ImGuiNative.igCombo_Str_arr(ptr, current_item2, ptr5, items_count, popup_max_height_in_items);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				return b != 0;
			}
		}

		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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int* ptr3 = stackalloc int[items.Length];
			int num2 = 0;
			for (int i = 0; i < items.Length; i++)
			{
				string s = items[i];
				ptr3[i] = Encoding.UTF8.GetByteCount(s);
				num2 += ptr3[i] + 1;
			}
			byte* ptr4 = stackalloc byte[(int)(uint)num2];
			int num3 = 0;
			for (int j = 0; j < items.Length; j++)
			{
				string s2 = items[j];
				num3 += Util.GetUtf8(s2, ptr4 + num3, ptr3[j]);
				ptr4[num3++] = 0;
			}
			byte** ptr5 = stackalloc byte*[items.Length];
			num3 = 0;
			for (int k = 0; k < items.Length; k++)
			{
				ptr5[k] = ptr4 + num3;
				num3 += ptr3[k] + 1;
			}
			int popup_max_height_in_items = -1;
			fixed (int* current_item2 = &current_item)
			{
				byte b = ImGuiNative.igCombo_Str_arr(ptr, current_item2, ptr5, items_count, popup_max_height_in_items);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				return b != 0;
			}
		}

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

		public unsafe static bool Combo(ReadOnlySpan<char> label, ref int current_item, ReadOnlySpan<char> items_separated_by_zeros)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (items_separated_by_zeros != null)
			{
				num2 = Encoding.UTF8.GetByteCount(items_separated_by_zeros);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(items_separated_by_zeros, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			int popup_max_height_in_items = -1;
			fixed (int* current_item2 = &current_item)
			{
				byte b = ImGuiNative.igCombo_Str(ptr, current_item2, ptr3, popup_max_height_in_items);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (items_separated_by_zeros != null)
			{
				num2 = Encoding.UTF8.GetByteCount(items_separated_by_zeros);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(items_separated_by_zeros, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			int popup_max_height_in_items = -1;
			fixed (int* current_item2 = &current_item)
			{
				byte b = ImGuiNative.igCombo_Str(ptr, current_item2, ptr3, popup_max_height_in_items);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool Combo(ReadOnlySpan<char> label, ref int current_item, ReadOnlySpan<char> items_separated_by_zeros, int popup_max_height_in_items)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (items_separated_by_zeros != null)
			{
				num2 = Encoding.UTF8.GetByteCount(items_separated_by_zeros);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(items_separated_by_zeros, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (int* current_item2 = &current_item)
			{
				byte b = ImGuiNative.igCombo_Str(ptr, current_item2, ptr3, popup_max_height_in_items);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (items_separated_by_zeros != null)
			{
				num2 = Encoding.UTF8.GetByteCount(items_separated_by_zeros);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(items_separated_by_zeros, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (int* current_item2 = &current_item)
			{
				byte b = ImGuiNative.igCombo_Str(ptr, current_item2, ptr3, popup_max_height_in_items);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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)
		{
			ImFontAtlas* nativePtr = shared_font_atlas.NativePtr;
			return ImGuiNative.igCreateContext(nativePtr);
		}

		public unsafe static bool DebugCheckVersionAndDataLayout(ReadOnlySpan<char> 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(version_str, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igDebugCheckVersionAndDataLayout(ptr, sz_io, sz_style, sz_vec2, sz_vec4, sz_drawvert, sz_drawidx);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(version_str, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igDebugCheckVersionAndDataLayout(ptr, sz_io, sz_style, sz_vec2, sz_vec4, sz_drawvert, sz_drawidx);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public static void DebugFlashStyleColor(ImGuiCol idx)
		{
			ImGuiNative.igDebugFlashStyleColor(idx);
		}

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

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

		public static void DebugStartItemPicker()
		{
			ImGuiNative.igDebugStartItemPicker();
		}

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

		public unsafe static void DebugTextEncoding(string text)
		{
			int num = 0;
			byte* ptr;
			if (text != null)
			{
				num = Encoding.UTF8.GetByteCount(text);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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()
		{
			IntPtr zero = IntPtr.Zero;
			ImGuiNative.igDestroyContext(zero);
		}

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

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

		public unsafe static uint DockSpace(uint dockspace_id)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			Vector2 size = default(Vector2);
			ImGuiDockNodeFlags flags = ImGuiDockNodeFlags.None;
			ImGuiWindowClass* window_class = null;
			return ImGuiNative.igDockSpace(dockspace_id, size, flags, window_class);
		}

		public unsafe static uint DockSpace(uint dockspace_id, Vector2 size)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			ImGuiDockNodeFlags flags = ImGuiDockNodeFlags.None;
			ImGuiWindowClass* window_class = null;
			return ImGuiNative.igDockSpace(dockspace_id, size, flags, window_class);
		}

		public unsafe static uint DockSpace(uint dockspace_id, Vector2 size, ImGuiDockNodeFlags flags)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			ImGuiWindowClass* window_class = null;
			return ImGuiNative.igDockSpace(dockspace_id, size, flags, window_class);
		}

		public unsafe static uint DockSpace(uint dockspace_id, Vector2 size, ImGuiDockNodeFlags flags, ImGuiWindowClassPtr window_class)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			ImGuiWindowClass* nativePtr = window_class.NativePtr;
			return ImGuiNative.igDockSpace(dockspace_id, size, flags, nativePtr);
		}

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

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

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

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

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

		public unsafe static bool DragFloat(ReadOnlySpan<char> label, ref float v)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (float* v2 = &v)
			{
				byte b = ImGuiNative.igDragFloat(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

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

		public unsafe static bool DragFloat(ReadOnlySpan<char> label, ref float v, float v_speed)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (float* v2 = &v)
			{
				byte b = ImGuiNative.igDragFloat(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (float* v2 = &v)
			{
				byte b = ImGuiNative.igDragFloat(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool DragFloat(ReadOnlySpan<char> label, ref float v, float v_speed, float v_min)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (float* v2 = &v)
			{
				byte b = ImGuiNative.igDragFloat(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (float* v2 = &v)
			{
				byte b = ImGuiNative.igDragFloat(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool DragFloat(ReadOnlySpan<char> 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%.3f");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (float* v2 = &v)
			{
				byte b = ImGuiNative.igDragFloat(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%.3f");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (float* v2 = &v)
			{
				byte b = ImGuiNative.igDragFloat(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

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

		public unsafe static bool DragFloat(ReadOnlySpan<char> label, ref float v, float v_speed, float v_min, float v_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (float* v2 = &v)
			{
				byte b = ImGuiNative.igDragFloat(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (float* v2 = &v)
			{
				byte b = ImGuiNative.igDragFloat(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool DragFloat2(ReadOnlySpan<char> label, ref Vector2 v)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (Vector2* v2 = &v)
			{
				byte b = ImGuiNative.igDragFloat2(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

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

		public unsafe static bool DragFloat2(ReadOnlySpan<char> label, ref Vector2 v, float v_speed)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (Vector2* v2 = &v)
			{
				byte b = ImGuiNative.igDragFloat2(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (Vector2* v2 = &v)
			{
				byte b = ImGuiNative.igDragFloat2(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool DragFloat2(ReadOnlySpan<char> label, ref Vector2 v, float v_speed, float v_min)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (Vector2* v2 = &v)
			{
				byte b = ImGuiNative.igDragFloat2(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (Vector2* v2 = &v)
			{
				byte b = ImGuiNative.igDragFloat2(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool DragFloat2(ReadOnlySpan<char> 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%.3f");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (Vector2* v2 = &v)
			{
				byte b = ImGuiNative.igDragFloat2(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%.3f");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (Vector2* v2 = &v)
			{
				byte b = ImGuiNative.igDragFloat2(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

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

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

		public unsafe static bool DragFloat3(ReadOnlySpan<char> label, ref Vector3 v)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (Vector3* v2 = &v)
			{
				byte b = ImGuiNative.igDragFloat3(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

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

		public unsafe static bool DragFloat3(ReadOnlySpan<char> label, ref Vector3 v, float v_speed)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (Vector3* v2 = &v)
			{
				byte b = ImGuiNative.igDragFloat3(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (Vector3* v2 = &v)
			{
				byte b = ImGuiNative.igDragFloat3(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool DragFloat3(ReadOnlySpan<char> label, ref Vector3 v, float v_speed, float v_min)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (Vector3* v2 = &v)
			{
				byte b = ImGuiNative.igDragFloat3(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (Vector3* v2 = &v)
			{
				byte b = ImGuiNative.igDragFloat3(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool DragFloat3(ReadOnlySpan<char> 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%.3f");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (Vector3* v2 = &v)
			{
				byte b = ImGuiNative.igDragFloat3(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%.3f");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (Vector3* v2 = &v)
			{
				byte b = ImGuiNative.igDragFloat3(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

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

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

		public unsafe static bool DragFloat4(ReadOnlySpan<char> label, ref Vector4 v)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (Vector4* v2 = &v)
			{
				byte b = ImGuiNative.igDragFloat4(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

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

		public unsafe static bool DragFloat4(ReadOnlySpan<char> label, ref Vector4 v, float v_speed)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (Vector4* v2 = &v)
			{
				byte b = ImGuiNative.igDragFloat4(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (Vector4* v2 = &v)
			{
				byte b = ImGuiNative.igDragFloat4(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool DragFloat4(ReadOnlySpan<char> label, ref Vector4 v, float v_speed, float v_min)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (Vector4* v2 = &v)
			{
				byte b = ImGuiNative.igDragFloat4(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (Vector4* v2 = &v)
			{
				byte b = ImGuiNative.igDragFloat4(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool DragFloat4(ReadOnlySpan<char> 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%.3f");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (Vector4* v2 = &v)
			{
				byte b = ImGuiNative.igDragFloat4(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%.3f");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (Vector4* v2 = &v)
			{
				byte b = ImGuiNative.igDragFloat4(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

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

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

		public unsafe static bool DragFloatRange2(ReadOnlySpan<char> label, ref float v_current_min, ref float v_current_max)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[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 b = ImGuiNative.igDragFloatRange2(ptr, v_current_min2, v_current_max2, v_speed, v_min, v_max, ptr3, format_max, flags);
					if (num > 2048)
					{
						Util.Free(ptr);
					}
					if (num2 > 2048)
					{
						Util.Free(ptr3);
					}
					return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[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 b = ImGuiNative.igDragFloatRange2(ptr, v_current_min2, v_current_max2, v_speed, v_min, v_max, ptr3, format_max, flags);
					if (num > 2048)
					{
						Util.Free(ptr);
					}
					if (num2 > 2048)
					{
						Util.Free(ptr3);
					}
					return b != 0;
				}
			}
		}

		public unsafe static bool DragFloatRange2(ReadOnlySpan<char> 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[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 b = ImGuiNative.igDragFloatRange2(ptr, v_current_min2, v_current_max2, v_speed, v_min, v_max, ptr3, format_max, flags);
					if (num > 2048)
					{
						Util.Free(ptr);
					}
					if (num2 > 2048)
					{
						Util.Free(ptr3);
					}
					return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[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 b = ImGuiNative.igDragFloatRange2(ptr, v_current_min2, v_current_max2, v_speed, v_min, v_max, ptr3, format_max, flags);
					if (num > 2048)
					{
						Util.Free(ptr);
					}
					if (num2 > 2048)
					{
						Util.Free(ptr3);
					}
					return b != 0;
				}
			}
		}

		public unsafe static bool DragFloatRange2(ReadOnlySpan<char> 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[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 b = ImGuiNative.igDragFloatRange2(ptr, v_current_min2, v_current_max2, v_speed, v_min, v_max, ptr3, format_max, flags);
					if (num > 2048)
					{
						Util.Free(ptr);
					}
					if (num2 > 2048)
					{
						Util.Free(ptr3);
					}
					return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[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 b = ImGuiNative.igDragFloatRange2(ptr, v_current_min2, v_current_max2, v_speed, v_min, v_max, ptr3, format_max, flags);
					if (num > 2048)
					{
						Util.Free(ptr);
					}
					if (num2 > 2048)
					{
						Util.Free(ptr3);
					}
					return b != 0;
				}
			}
		}

		public unsafe static bool DragFloatRange2(ReadOnlySpan<char> 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%.3f");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[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 b = ImGuiNative.igDragFloatRange2(ptr, v_current_min2, v_current_max2, v_speed, v_min, v_max, ptr3, format_max, flags);
					if (num > 2048)
					{
						Util.Free(ptr);
					}
					if (num2 > 2048)
					{
						Util.Free(ptr3);
					}
					return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%.3f");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[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 b = ImGuiNative.igDragFloatRange2(ptr, v_current_min2, v_current_max2, v_speed, v_min, v_max, ptr3, format_max, flags);
					if (num > 2048)
					{
						Util.Free(ptr);
					}
					if (num2 > 2048)
					{
						Util.Free(ptr3);
					}
					return b != 0;
				}
			}
		}

		public unsafe static bool DragFloatRange2(ReadOnlySpan<char> label, ref float v_current_min, ref float v_current_max, float v_speed, float v_min, float v_max, ReadOnlySpan<char> format)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = 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 b = ImGuiNative.igDragFloatRange2(ptr, v_current_min2, v_current_max2, v_speed, v_min, v_max, ptr3, format_max, flags);
					if (num > 2048)
					{
						Util.Free(ptr);
					}
					if (num2 > 2048)
					{
						Util.Free(ptr3);
					}
					return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = 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 b = ImGuiNative.igDragFloatRange2(ptr, v_current_min2, v_current_max2, v_speed, v_min, v_max, ptr3, format_max, flags);
					if (num > 2048)
					{
						Util.Free(ptr);
					}
					if (num2 > 2048)
					{
						Util.Free(ptr3);
					}
					return b != 0;
				}
			}
		}

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

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

		public unsafe static bool DragInt(ReadOnlySpan<char> label, ref int v)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igDragInt(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

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

		public unsafe static bool DragInt(ReadOnlySpan<char> label, ref int v, float v_speed)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igDragInt(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igDragInt(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool DragInt(ReadOnlySpan<char> label, ref int v, float v_speed, int v_min)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igDragInt(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igDragInt(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool DragInt(ReadOnlySpan<char> 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%d");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igDragInt(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%d");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igDragInt(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

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

		public unsafe static bool DragInt(ReadOnlySpan<char> label, ref int v, float v_speed, int v_min, int v_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igDragInt(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igDragInt(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool DragInt2(ReadOnlySpan<char> label, ref int v)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igDragInt2(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

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

		public unsafe static bool DragInt2(ReadOnlySpan<char> label, ref int v, float v_speed)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igDragInt2(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igDragInt2(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool DragInt2(ReadOnlySpan<char> label, ref int v, float v_speed, int v_min)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igDragInt2(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igDragInt2(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool DragInt2(ReadOnlySpan<char> 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%d");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igDragInt2(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%d");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igDragInt2(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

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

		public unsafe static bool DragInt2(ReadOnlySpan<char> label, ref int v, float v_speed, int v_min, int v_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igDragInt2(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igDragInt2(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool DragInt3(ReadOnlySpan<char> label, ref int v)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igDragInt3(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

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

		public unsafe static bool DragInt3(ReadOnlySpan<char> label, ref int v, float v_speed)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igDragInt3(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igDragInt3(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool DragInt3(ReadOnlySpan<char> label, ref int v, float v_speed, int v_min)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igDragInt3(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igDragInt3(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool DragInt3(ReadOnlySpan<char> 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%d");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igDragInt3(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%d");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igDragInt3(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

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

		public unsafe static bool DragInt3(ReadOnlySpan<char> label, ref int v, float v_speed, int v_min, int v_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igDragInt3(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igDragInt3(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool DragInt4(ReadOnlySpan<char> label, ref int v)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igDragInt4(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

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

		public unsafe static bool DragInt4(ReadOnlySpan<char> label, ref int v, float v_speed)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igDragInt4(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igDragInt4(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool DragInt4(ReadOnlySpan<char> label, ref int v, float v_speed, int v_min)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igDragInt4(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igDragInt4(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool DragInt4(ReadOnlySpan<char> 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%d");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igDragInt4(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%d");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igDragInt4(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

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

		public unsafe static bool DragInt4(ReadOnlySpan<char> label, ref int v, float v_speed, int v_min, int v_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igDragInt4(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igDragInt4(ptr, v2, v_speed, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool DragIntRange2(ReadOnlySpan<char> label, ref int v_current_min, ref int v_current_max)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[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 b = ImGuiNative.igDragIntRange2(ptr, v_current_min2, v_current_max2, v_speed, v_min, v_max, ptr3, format_max, flags);
					if (num > 2048)
					{
						Util.Free(ptr);
					}
					if (num2 > 2048)
					{
						Util.Free(ptr3);
					}
					return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[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 b = ImGuiNative.igDragIntRange2(ptr, v_current_min2, v_current_max2, v_speed, v_min, v_max, ptr3, format_max, flags);
					if (num > 2048)
					{
						Util.Free(ptr);
					}
					if (num2 > 2048)
					{
						Util.Free(ptr3);
					}
					return b != 0;
				}
			}
		}

		public unsafe static bool DragIntRange2(ReadOnlySpan<char> 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[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 b = ImGuiNative.igDragIntRange2(ptr, v_current_min2, v_current_max2, v_speed, v_min, v_max, ptr3, format_max, flags);
					if (num > 2048)
					{
						Util.Free(ptr);
					}
					if (num2 > 2048)
					{
						Util.Free(ptr3);
					}
					return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[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 b = ImGuiNative.igDragIntRange2(ptr, v_current_min2, v_current_max2, v_speed, v_min, v_max, ptr3, format_max, flags);
					if (num > 2048)
					{
						Util.Free(ptr);
					}
					if (num2 > 2048)
					{
						Util.Free(ptr3);
					}
					return b != 0;
				}
			}
		}

		public unsafe static bool DragIntRange2(ReadOnlySpan<char> 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[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 b = ImGuiNative.igDragIntRange2(ptr, v_current_min2, v_current_max2, v_speed, v_min, v_max, ptr3, format_max, flags);
					if (num > 2048)
					{
						Util.Free(ptr);
					}
					if (num2 > 2048)
					{
						Util.Free(ptr3);
					}
					return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[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 b = ImGuiNative.igDragIntRange2(ptr, v_current_min2, v_current_max2, v_speed, v_min, v_max, ptr3, format_max, flags);
					if (num > 2048)
					{
						Util.Free(ptr);
					}
					if (num2 > 2048)
					{
						Util.Free(ptr3);
					}
					return b != 0;
				}
			}
		}

		public unsafe static bool DragIntRange2(ReadOnlySpan<char> 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%d");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[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 b = ImGuiNative.igDragIntRange2(ptr, v_current_min2, v_current_max2, v_speed, v_min, v_max, ptr3, format_max, flags);
					if (num > 2048)
					{
						Util.Free(ptr);
					}
					if (num2 > 2048)
					{
						Util.Free(ptr3);
					}
					return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%d");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[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 b = ImGuiNative.igDragIntRange2(ptr, v_current_min2, v_current_max2, v_speed, v_min, v_max, ptr3, format_max, flags);
					if (num > 2048)
					{
						Util.Free(ptr);
					}
					if (num2 > 2048)
					{
						Util.Free(ptr3);
					}
					return b != 0;
				}
			}
		}

		public unsafe static bool DragIntRange2(ReadOnlySpan<char> label, ref int v_current_min, ref int v_current_max, float v_speed, int v_min, int v_max, ReadOnlySpan<char> format)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = 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 b = ImGuiNative.igDragIntRange2(ptr, v_current_min2, v_current_max2, v_speed, v_min, v_max, ptr3, format_max, flags);
					if (num > 2048)
					{
						Util.Free(ptr);
					}
					if (num2 > 2048)
					{
						Util.Free(ptr3);
					}
					return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = 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 b = ImGuiNative.igDragIntRange2(ptr, v_current_min2, v_current_max2, v_speed, v_min, v_max, ptr3, format_max, flags);
					if (num > 2048)
					{
						Util.Free(ptr);
					}
					if (num2 > 2048)
					{
						Util.Free(ptr3);
					}
					return b != 0;
				}
			}
		}

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

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

		public unsafe static bool DragScalar(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igDragScalar(ptr, data_type, p_data2, v_speed, p_min, p_max, format, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igDragScalar(ptr, data_type, p_data2, v_speed, p_min, p_max, format, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool DragScalar(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, float v_speed)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igDragScalar(ptr, data_type, p_data2, v_speed, p_min, p_max, format, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igDragScalar(ptr, data_type, p_data2, v_speed, p_min, p_max, format, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool DragScalar(ReadOnlySpan<char> 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igDragScalar(ptr, data_type, p_data2, v_speed, p_min2, p_max, format, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igDragScalar(ptr, data_type, p_data2, v_speed, p_min2, p_max, format, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool DragScalar(ReadOnlySpan<char> 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igDragScalar(ptr, data_type, p_data2, v_speed, p_min2, p_max2, format, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igDragScalar(ptr, data_type, p_data2, v_speed, p_min2, p_max2, format, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool DragScalar(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, float v_speed, IntPtr p_min, IntPtr p_max, ReadOnlySpan<char> format)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			byte b = ImGuiNative.igDragScalar(ptr, data_type, p_data2, v_speed, p_min2, p_max2, ptr3, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr3);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			byte b = ImGuiNative.igDragScalar(ptr, data_type, p_data2, v_speed, p_min2, p_max2, ptr3, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr3);
			}
			return b != 0;
		}

		public unsafe static bool DragScalar(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, float v_speed, IntPtr p_min, IntPtr p_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			byte b = ImGuiNative.igDragScalar(ptr, data_type, p_data2, v_speed, p_min2, p_max2, ptr3, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr3);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			byte b = ImGuiNative.igDragScalar(ptr, data_type, p_data2, v_speed, p_min2, p_max2, ptr3, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr3);
			}
			return b != 0;
		}

		public unsafe static bool DragScalarN(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, int components)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igDragScalarN(ptr, data_type, p_data2, components, v_speed, p_min, p_max, format, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igDragScalarN(ptr, data_type, p_data2, components, v_speed, p_min, p_max, format, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool DragScalarN(ReadOnlySpan<char> 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igDragScalarN(ptr, data_type, p_data2, components, v_speed, p_min, p_max, format, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igDragScalarN(ptr, data_type, p_data2, components, v_speed, p_min, p_max, format, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool DragScalarN(ReadOnlySpan<char> 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igDragScalarN(ptr, data_type, p_data2, components, v_speed, p_min2, p_max, format, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igDragScalarN(ptr, data_type, p_data2, components, v_speed, p_min2, p_max, format, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool DragScalarN(ReadOnlySpan<char> 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igDragScalarN(ptr, data_type, p_data2, components, v_speed, p_min2, p_max2, format, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igDragScalarN(ptr, data_type, p_data2, components, v_speed, p_min2, p_max2, format, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool DragScalarN(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, int components, float v_speed, IntPtr p_min, IntPtr p_max, ReadOnlySpan<char> format)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			byte b = ImGuiNative.igDragScalarN(ptr, data_type, p_data2, components, v_speed, p_min2, p_max2, ptr3, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr3);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			byte b = ImGuiNative.igDragScalarN(ptr, data_type, p_data2, components, v_speed, p_min2, p_max2, ptr3, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr3);
			}
			return b != 0;
		}

		public unsafe static bool DragScalarN(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, int components, float v_speed, IntPtr p_min, IntPtr p_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			byte b = ImGuiNative.igDragScalarN(ptr, data_type, p_data2, components, v_speed, p_min2, p_max2, ptr3, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr3);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			byte b = ImGuiNative.igDragScalarN(ptr, data_type, p_data2, components, v_speed, p_min2, p_max2, ptr3, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr3);
			}
			return b != 0;
		}

		public static void Dummy(Vector2 size)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			ImGuiNative.igDummy(size);
		}

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

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

		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 unsafe static ImGuiMultiSelectIOPtr EndMultiSelect()
		{
			ImGuiMultiSelectIO* nativePtr = ImGuiNative.igEndMultiSelect();
			return new ImGuiMultiSelectIOPtr(nativePtr);
		}

		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)
		{
			ImGuiViewport* nativePtr = ImGuiNative.igFindViewportByID(id);
			return new ImGuiViewportPtr(nativePtr);
		}

		public unsafe static ImGuiViewportPtr FindViewportByPlatformHandle(IntPtr platform_handle)
		{
			void* platform_handle2 = platform_handle.ToPointer();
			ImGuiViewport* nativePtr = ImGuiNative.igFindViewportByPlatformHandle(platform_handle2);
			return new ImGuiViewportPtr(nativePtr);
		}

		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()
		{
			ImGuiViewport* viewport = null;
			ImDrawList* nativePtr = ImGuiNative.igGetBackgroundDrawList(viewport);
			return new ImDrawListPtr(nativePtr);
		}

		public unsafe static ImDrawListPtr GetBackgroundDrawList(ImGuiViewportPtr viewport)
		{
			ImGuiViewport* nativePtr = viewport.NativePtr;
			ImDrawList* nativePtr2 = ImGuiNative.igGetBackgroundDrawList(nativePtr);
			return new ImDrawListPtr(nativePtr2);
		}

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

		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)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return ImGuiNative.igGetColorU32_Vec4(col);
		}

		public static uint GetColorU32(uint col)
		{
			float alpha_mul = 1f;
			return ImGuiNative.igGetColorU32_U32(col, alpha_mul);
		}

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

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

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

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

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

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

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

		public unsafe static Vector2 GetContentRegionAvail()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			Vector2 result = default(Vector2);
			ImGuiNative.igGetContentRegionAvail(&result);
			return result;
		}

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

		public unsafe static Vector2 GetCursorPos()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			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()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			Vector2 result = default(Vector2);
			ImGuiNative.igGetCursorScreenPos(&result);
			return result;
		}

		public unsafe static Vector2 GetCursorStartPos()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			Vector2 result = default(Vector2);
			ImGuiNative.igGetCursorStartPos(&result);
			return result;
		}

		public unsafe static ImGuiPayloadPtr GetDragDropPayload()
		{
			ImGuiPayload* nativePtr = ImGuiNative.igGetDragDropPayload();
			return new ImGuiPayloadPtr(nativePtr);
		}

		public unsafe static ImDrawDataPtr GetDrawData()
		{
			ImDrawData* nativePtr = ImGuiNative.igGetDrawData();
			return new ImDrawDataPtr(nativePtr);
		}

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

		public unsafe static ImFontPtr GetFont()
		{
			ImFont* nativePtr = ImGuiNative.igGetFont();
			return new ImFontPtr(nativePtr);
		}

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

		public unsafe static Vector2 GetFontTexUvWhitePixel()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			Vector2 result = default(Vector2);
			ImGuiNative.igGetFontTexUvWhitePixel(&result);
			return result;
		}

		public unsafe static ImDrawListPtr GetForegroundDrawList()
		{
			ImGuiViewport* viewport = null;
			ImDrawList* nativePtr = ImGuiNative.igGetForegroundDrawList_ViewportPtr(viewport);
			return new ImDrawListPtr(nativePtr);
		}

		public unsafe static ImDrawListPtr GetForegroundDrawList(ImGuiViewportPtr viewport)
		{
			ImGuiViewport* nativePtr = viewport.NativePtr;
			ImDrawList* nativePtr2 = ImGuiNative.igGetForegroundDrawList_ViewportPtr(nativePtr);
			return new ImDrawListPtr(nativePtr2);
		}

		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(ReadOnlySpan<char> str_id)
		{
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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(string str_id)
		{
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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)
		{
			void* ptr_id2 = ptr_id.ToPointer();
			return ImGuiNative.igGetID_Ptr(ptr_id2);
		}

		public static uint GetID(int int_id)
		{
			return ImGuiNative.igGetID_Int(int_id);
		}

		public unsafe static ImGuiIOPtr GetIO()
		{
			ImGuiIO* nativePtr = ImGuiNative.igGetIO();
			return new ImGuiIOPtr(nativePtr);
		}

		public static uint GetItemID()
		{
			return ImGuiNative.igGetItemID();
		}

		public unsafe static Vector2 GetItemRectMax()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			Vector2 result = default(Vector2);
			ImGuiNative.igGetItemRectMax(&result);
			return result;
		}

		public unsafe static Vector2 GetItemRectMin()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			Vector2 result = default(Vector2);
			ImGuiNative.igGetItemRectMin(&result);
			return result;
		}

		public unsafe static Vector2 GetItemRectSize()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			Vector2 result = default(Vector2);
			ImGuiNative.igGetItemRectSize(&result);
			return result;
		}

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

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

		public unsafe static ImGuiViewportPtr GetMainViewport()
		{
			ImGuiViewport* nativePtr = ImGuiNative.igGetMainViewport();
			return new ImGuiViewportPtr(nativePtr);
		}

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

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

		public unsafe static Vector2 GetMouseDragDelta()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			Vector2 result = default(Vector2);
			ImGuiNative.igGetMouseDragDelta(&result, button, lock_threshold);
			return result;
		}

		public unsafe static Vector2 GetMousePos()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			Vector2 result = default(Vector2);
			ImGuiNative.igGetMousePos(&result);
			return result;
		}

		public unsafe static Vector2 GetMousePosOnOpeningCurrentPopup()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			Vector2 result = default(Vector2);
			ImGuiNative.igGetMousePosOnOpeningCurrentPopup(&result);
			return result;
		}

		public unsafe static ImGuiPlatformIOPtr GetPlatformIO()
		{
			ImGuiPlatformIO* nativePtr = ImGuiNative.igGetPlatformIO();
			return new ImGuiPlatformIOPtr(nativePtr);
		}

		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()
		{
			ImGuiStorage* nativePtr = ImGuiNative.igGetStateStorage();
			return new ImGuiStoragePtr(nativePtr);
		}

		public unsafe static ImGuiStylePtr GetStyle()
		{
			ImGuiStyle* nativePtr = ImGuiNative.igGetStyle();
			return new ImGuiStylePtr(nativePtr);
		}

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

		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()
		{
			byte* ptr = ImGuiNative.igGetVersion();
			return Util.StringFromPtr(ptr);
		}

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

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

		public unsafe static ImDrawListPtr GetWindowDrawList()
		{
			ImDrawList* nativePtr = ImGuiNative.igGetWindowDrawList();
			return new ImDrawListPtr(nativePtr);
		}

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

		public unsafe static Vector2 GetWindowPos()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			Vector2 result = default(Vector2);
			ImGuiNative.igGetWindowPos(&result);
			return result;
		}

		public unsafe static Vector2 GetWindowSize()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			Vector2 result = default(Vector2);
			ImGuiNative.igGetWindowSize(&result);
			return result;
		}

		public unsafe static ImGuiViewportPtr GetWindowViewport()
		{
			ImGuiViewport* nativePtr = ImGuiNative.igGetWindowViewport();
			return new ImGuiViewportPtr(nativePtr);
		}

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

		public static void Image(IntPtr user_texture_id, Vector2 image_size)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			Vector2 uv = default(Vector2);
			Vector2 uv2 = default(Vector2);
			((Vector2)(ref uv2))..ctor(1f, 1f);
			Vector4 tint_col = default(Vector4);
			((Vector4)(ref tint_col))..ctor(1f, 1f, 1f, 1f);
			ImGuiNative.igImage(user_texture_id, image_size, uv, uv2, tint_col, default(Vector4));
		}

		public static void Image(IntPtr user_texture_id, Vector2 image_size, Vector2 uv0)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			Vector2 uv = default(Vector2);
			((Vector2)(ref uv))..ctor(1f, 1f);
			Vector4 tint_col = default(Vector4);
			((Vector4)(ref tint_col))..ctor(1f, 1f, 1f, 1f);
			ImGuiNative.igImage(user_texture_id, image_size, uv0, uv, tint_col, default(Vector4));
		}

		public static void Image(IntPtr user_texture_id, Vector2 image_size, Vector2 uv0, Vector2 uv1)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			Vector4 tint_col = default(Vector4);
			((Vector4)(ref tint_col))..ctor(1f, 1f, 1f, 1f);
			ImGuiNative.igImage(user_texture_id, image_size, uv0, uv1, tint_col, default(Vector4));
		}

		public static void Image(IntPtr user_texture_id, Vector2 image_size, Vector2 uv0, Vector2 uv1, Vector4 tint_col)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			ImGuiNative.igImage(user_texture_id, image_size, uv0, uv1, tint_col, default(Vector4));
		}

		public static void Image(IntPtr user_texture_id, Vector2 image_size, Vector2 uv0, Vector2 uv1, Vector4 tint_col, Vector4 border_col)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			ImGuiNative.igImage(user_texture_id, image_size, uv0, uv1, tint_col, border_col);
		}

		public unsafe static bool ImageButton(ReadOnlySpan<char> str_id, IntPtr user_texture_id, Vector2 image_size)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			Vector2 uv = default(Vector2);
			Vector2 uv2 = default(Vector2);
			((Vector2)(ref uv2))..ctor(1f, 1f);
			Vector4 bg_col = default(Vector4);
			Vector4 tint_col = default(Vector4);
			((Vector4)(ref tint_col))..ctor(1f, 1f, 1f, 1f);
			byte b = ImGuiNative.igImageButton(ptr, user_texture_id, image_size, uv, uv2, bg_col, tint_col);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool ImageButton(string str_id, IntPtr user_texture_id, Vector2 image_size)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			Vector2 uv = default(Vector2);
			Vector2 uv2 = default(Vector2);
			((Vector2)(ref uv2))..ctor(1f, 1f);
			Vector4 bg_col = default(Vector4);
			Vector4 tint_col = default(Vector4);
			((Vector4)(ref tint_col))..ctor(1f, 1f, 1f, 1f);
			byte b = ImGuiNative.igImageButton(ptr, user_texture_id, image_size, uv, uv2, bg_col, tint_col);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool ImageButton(ReadOnlySpan<char> str_id, IntPtr user_texture_id, Vector2 image_size, Vector2 uv0)
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			Vector2 uv = default(Vector2);
			((Vector2)(ref uv))..ctor(1f, 1f);
			Vector4 bg_col = default(Vector4);
			Vector4 tint_col = default(Vector4);
			((Vector4)(ref tint_col))..ctor(1f, 1f, 1f, 1f);
			byte b = ImGuiNative.igImageButton(ptr, user_texture_id, image_size, uv0, uv, bg_col, tint_col);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool ImageButton(string str_id, IntPtr user_texture_id, Vector2 image_size, Vector2 uv0)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			Vector2 uv = default(Vector2);
			((Vector2)(ref uv))..ctor(1f, 1f);
			Vector4 bg_col = default(Vector4);
			Vector4 tint_col = default(Vector4);
			((Vector4)(ref tint_col))..ctor(1f, 1f, 1f, 1f);
			byte b = ImGuiNative.igImageButton(ptr, user_texture_id, image_size, uv0, uv, bg_col, tint_col);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool ImageButton(ReadOnlySpan<char> str_id, IntPtr user_texture_id, Vector2 image_size, Vector2 uv0, Vector2 uv1)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			Vector4 bg_col = default(Vector4);
			Vector4 tint_col = default(Vector4);
			((Vector4)(ref tint_col))..ctor(1f, 1f, 1f, 1f);
			byte b = ImGuiNative.igImageButton(ptr, user_texture_id, image_size, uv0, uv1, bg_col, tint_col);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool ImageButton(string str_id, IntPtr user_texture_id, Vector2 image_size, Vector2 uv0, Vector2 uv1)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			Vector4 bg_col = default(Vector4);
			Vector4 tint_col = default(Vector4);
			((Vector4)(ref tint_col))..ctor(1f, 1f, 1f, 1f);
			byte b = ImGuiNative.igImageButton(ptr, user_texture_id, image_size, uv0, uv1, bg_col, tint_col);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool ImageButton(ReadOnlySpan<char> str_id, IntPtr user_texture_id, Vector2 image_size, Vector2 uv0, Vector2 uv1, Vector4 bg_col)
		{
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			Vector4 tint_col = default(Vector4);
			((Vector4)(ref tint_col))..ctor(1f, 1f, 1f, 1f);
			byte b = ImGuiNative.igImageButton(ptr, user_texture_id, image_size, uv0, uv1, bg_col, tint_col);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool ImageButton(string str_id, IntPtr user_texture_id, Vector2 image_size, Vector2 uv0, Vector2 uv1, Vector4 bg_col)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			Vector4 tint_col = default(Vector4);
			((Vector4)(ref tint_col))..ctor(1f, 1f, 1f, 1f);
			byte b = ImGuiNative.igImageButton(ptr, user_texture_id, image_size, uv0, uv1, bg_col, tint_col);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool ImageButton(ReadOnlySpan<char> str_id, IntPtr user_texture_id, Vector2 image_size, Vector2 uv0, Vector2 uv1, Vector4 bg_col, Vector4 tint_col)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igImageButton(ptr, user_texture_id, image_size, uv0, uv1, bg_col, tint_col);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool ImageButton(string str_id, IntPtr user_texture_id, Vector2 image_size, Vector2 uv0, Vector2 uv1, Vector4 bg_col, Vector4 tint_col)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igImageButton(ptr, user_texture_id, image_size, uv0, uv1, bg_col, tint_col);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

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

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

		public unsafe static bool InputDouble(ReadOnlySpan<char> label, ref double v)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.6f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
			fixed (double* v2 = &v)
			{
				byte b = ImGuiNative.igInputDouble(ptr, v2, step, step_fast, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

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

		public unsafe static bool InputDouble(ReadOnlySpan<char> label, ref double v, double step)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.6f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
			fixed (double* v2 = &v)
			{
				byte b = ImGuiNative.igInputDouble(ptr, v2, step, step_fast, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.6f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
			fixed (double* v2 = &v)
			{
				byte b = ImGuiNative.igInputDouble(ptr, v2, step, step_fast, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

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

		public unsafe static bool InputDouble(ReadOnlySpan<char> label, ref double v, double step, double step_fast, ReadOnlySpan<char> format)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
			fixed (double* v2 = &v)
			{
				byte b = ImGuiNative.igInputDouble(ptr, v2, step, step_fast, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
			fixed (double* v2 = &v)
			{
				byte b = ImGuiNative.igInputDouble(ptr, v2, step, step_fast, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool InputDouble(ReadOnlySpan<char> label, ref double v, double step, double step_fast, ReadOnlySpan<char> format, ImGuiInputTextFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (double* v2 = &v)
			{
				byte b = ImGuiNative.igInputDouble(ptr, v2, step, step_fast, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (double* v2 = &v)
			{
				byte b = ImGuiNative.igInputDouble(ptr, v2, step, step_fast, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool InputFloat(ReadOnlySpan<char> label, ref float v)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
			fixed (float* v2 = &v)
			{
				byte b = ImGuiNative.igInputFloat(ptr, v2, step, step_fast, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

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

		public unsafe static bool InputFloat(ReadOnlySpan<char> label, ref float v, float step)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
			fixed (float* v2 = &v)
			{
				byte b = ImGuiNative.igInputFloat(ptr, v2, step, step_fast, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
			fixed (float* v2 = &v)
			{
				byte b = ImGuiNative.igInputFloat(ptr, v2, step, step_fast, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

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

		public unsafe static bool InputFloat(ReadOnlySpan<char> label, ref float v, float step, float step_fast, ReadOnlySpan<char> format)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
			fixed (float* v2 = &v)
			{
				byte b = ImGuiNative.igInputFloat(ptr, v2, step, step_fast, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
			fixed (float* v2 = &v)
			{
				byte b = ImGuiNative.igInputFloat(ptr, v2, step, step_fast, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool InputFloat(ReadOnlySpan<char> label, ref float v, float step, float step_fast, ReadOnlySpan<char> format, ImGuiInputTextFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (float* v2 = &v)
			{
				byte b = ImGuiNative.igInputFloat(ptr, v2, step, step_fast, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (float* v2 = &v)
			{
				byte b = ImGuiNative.igInputFloat(ptr, v2, step, step_fast, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

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

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

		public unsafe static bool InputFloat2(ReadOnlySpan<char> label, ref Vector2 v, ReadOnlySpan<char> format)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
			fixed (Vector2* v2 = &v)
			{
				byte b = ImGuiNative.igInputFloat2(ptr, v2, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
			fixed (Vector2* v2 = &v)
			{
				byte b = ImGuiNative.igInputFloat2(ptr, v2, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool InputFloat2(ReadOnlySpan<char> label, ref Vector2 v, ReadOnlySpan<char> format, ImGuiInputTextFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (Vector2* v2 = &v)
			{
				byte b = ImGuiNative.igInputFloat2(ptr, v2, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (Vector2* v2 = &v)
			{
				byte b = ImGuiNative.igInputFloat2(ptr, v2, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

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

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

		public unsafe static bool InputFloat3(ReadOnlySpan<char> label, ref Vector3 v, ReadOnlySpan<char> format)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
			fixed (Vector3* v2 = &v)
			{
				byte b = ImGuiNative.igInputFloat3(ptr, v2, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
			fixed (Vector3* v2 = &v)
			{
				byte b = ImGuiNative.igInputFloat3(ptr, v2, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool InputFloat3(ReadOnlySpan<char> label, ref Vector3 v, ReadOnlySpan<char> format, ImGuiInputTextFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (Vector3* v2 = &v)
			{
				byte b = ImGuiNative.igInputFloat3(ptr, v2, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (Vector3* v2 = &v)
			{
				byte b = ImGuiNative.igInputFloat3(ptr, v2, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

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

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

		public unsafe static bool InputFloat4(ReadOnlySpan<char> label, ref Vector4 v, ReadOnlySpan<char> format)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
			fixed (Vector4* v2 = &v)
			{
				byte b = ImGuiNative.igInputFloat4(ptr, v2, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
			fixed (Vector4* v2 = &v)
			{
				byte b = ImGuiNative.igInputFloat4(ptr, v2, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool InputFloat4(ReadOnlySpan<char> label, ref Vector4 v, ReadOnlySpan<char> format, ImGuiInputTextFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (Vector4* v2 = &v)
			{
				byte b = ImGuiNative.igInputFloat4(ptr, v2, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (Vector4* v2 = &v)
			{
				byte b = ImGuiNative.igInputFloat4(ptr, v2, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool InputInt(ReadOnlySpan<char> label, ref int v)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igInputInt(ptr, v2, step, step_fast, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				return b != 0;
			}
		}

		public unsafe static bool InputInt(string label, ref int v)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igInputInt(ptr, v2, step, step_fast, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				return b != 0;
			}
		}

		public unsafe static bool InputInt(ReadOnlySpan<char> label, ref int v, int step)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igInputInt(ptr, v2, step, step_fast, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igInputInt(ptr, v2, step, step_fast, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				return b != 0;
			}
		}

		public unsafe static bool InputInt(ReadOnlySpan<char> label, ref int v, int step, int step_fast)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igInputInt(ptr, v2, step, step_fast, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igInputInt(ptr, v2, step, step_fast, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				return b != 0;
			}
		}

		public unsafe static bool InputInt(ReadOnlySpan<char> label, ref int v, int step, int step_fast, ImGuiInputTextFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igInputInt(ptr, v2, step, step_fast, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igInputInt(ptr, v2, step, step_fast, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				return b != 0;
			}
		}

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

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

		public unsafe static bool InputInt2(ReadOnlySpan<char> label, ref int v, ImGuiInputTextFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igInputInt2(ptr, v2, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igInputInt2(ptr, v2, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				return b != 0;
			}
		}

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

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

		public unsafe static bool InputInt3(ReadOnlySpan<char> label, ref int v, ImGuiInputTextFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igInputInt3(ptr, v2, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igInputInt3(ptr, v2, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				return b != 0;
			}
		}

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

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

		public unsafe static bool InputInt4(ReadOnlySpan<char> label, ref int v, ImGuiInputTextFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igInputInt4(ptr, v2, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igInputInt4(ptr, v2, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				return b != 0;
			}
		}

		public unsafe static bool InputScalar(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igInputScalar(ptr, data_type, p_data2, p_step, p_step_fast, format, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igInputScalar(ptr, data_type, p_data2, p_step, p_step_fast, format, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool InputScalar(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, IntPtr p_step)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igInputScalar(ptr, data_type, p_data2, p_step2, p_step_fast, format, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igInputScalar(ptr, data_type, p_data2, p_step2, p_step_fast, format, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool InputScalar(ReadOnlySpan<char> 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igInputScalar(ptr, data_type, p_data2, p_step2, p_step_fast2, format, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igInputScalar(ptr, data_type, p_data2, p_step2, p_step_fast2, format, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool InputScalar(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, IntPtr p_step, IntPtr p_step_fast, ReadOnlySpan<char> format)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
			byte b = ImGuiNative.igInputScalar(ptr, data_type, p_data2, p_step2, p_step_fast2, ptr3, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr3);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
			byte b = ImGuiNative.igInputScalar(ptr, data_type, p_data2, p_step2, p_step_fast2, ptr3, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr3);
			}
			return b != 0;
		}

		public unsafe static bool InputScalar(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, IntPtr p_step, IntPtr p_step_fast, ReadOnlySpan<char> format, ImGuiInputTextFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			byte b = ImGuiNative.igInputScalar(ptr, data_type, p_data2, p_step2, p_step_fast2, ptr3, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr3);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			byte b = ImGuiNative.igInputScalar(ptr, data_type, p_data2, p_step2, p_step_fast2, ptr3, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr3);
			}
			return b != 0;
		}

		public unsafe static bool InputScalarN(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, int components)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igInputScalarN(ptr, data_type, p_data2, components, p_step, p_step_fast, format, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igInputScalarN(ptr, data_type, p_data2, components, p_step, p_step_fast, format, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool InputScalarN(ReadOnlySpan<char> 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igInputScalarN(ptr, data_type, p_data2, components, p_step2, p_step_fast, format, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igInputScalarN(ptr, data_type, p_data2, components, p_step2, p_step_fast, format, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool InputScalarN(ReadOnlySpan<char> 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igInputScalarN(ptr, data_type, p_data2, components, p_step2, p_step_fast2, format, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igInputScalarN(ptr, data_type, p_data2, components, p_step2, p_step_fast2, format, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool InputScalarN(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, int components, IntPtr p_step, IntPtr p_step_fast, ReadOnlySpan<char> format)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
			byte b = ImGuiNative.igInputScalarN(ptr, data_type, p_data2, components, p_step2, p_step_fast2, ptr3, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr3);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiInputTextFlags flags = ImGuiInputTextFlags.None;
			byte b = ImGuiNative.igInputScalarN(ptr, data_type, p_data2, components, p_step2, p_step_fast2, ptr3, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr3);
			}
			return b != 0;
		}

		public unsafe static bool InputScalarN(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, int components, IntPtr p_step, IntPtr p_step_fast, ReadOnlySpan<char> format, ImGuiInputTextFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			byte b = ImGuiNative.igInputScalarN(ptr, data_type, p_data2, components, p_step2, p_step_fast2, ptr3, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr3);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			byte b = ImGuiNative.igInputScalarN(ptr, data_type, p_data2, components, p_step2, p_step_fast2, ptr3, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr3);
			}
			return b != 0;
		}

		public unsafe static bool InvisibleButton(ReadOnlySpan<char> str_id, Vector2 size)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			ImGuiButtonFlags flags = ImGuiButtonFlags.None;
			byte b = ImGuiNative.igInvisibleButton(ptr, size, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool InvisibleButton(string str_id, Vector2 size)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			ImGuiButtonFlags flags = ImGuiButtonFlags.None;
			byte b = ImGuiNative.igInvisibleButton(ptr, size, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool InvisibleButton(ReadOnlySpan<char> str_id, Vector2 size, ImGuiButtonFlags flags)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igInvisibleButton(ptr, size, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool InvisibleButton(string str_id, Vector2 size, ImGuiButtonFlags flags)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igInvisibleButton(ptr, size, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		public static bool IsItemToggledSelection()
		{
			byte b = ImGuiNative.igIsItemToggledSelection();
			return b != 0;
		}

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

		public static bool IsKeyChordPressed(ImGuiKey key_chord)
		{
			byte b = ImGuiNative.igIsKeyChordPressed_Nil(key_chord);
			return b != 0;
		}

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

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

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

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

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

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

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

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

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

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

		public static bool IsMouseHoveringRect(Vector2 r_min, Vector2 r_max)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			byte clip = 1;
			byte b = ImGuiNative.igIsMouseHoveringRect(r_min, r_max, clip);
			return b != 0;
		}

		public static bool IsMouseHoveringRect(Vector2 r_min, Vector2 r_max, bool clip)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			byte clip2 = (byte)(clip ? 1 : 0);
			byte b = ImGuiNative.igIsMouseHoveringRect(r_min, r_max, clip2);
			return b != 0;
		}

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

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

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

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

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

		public unsafe static bool IsPopupOpen(ReadOnlySpan<char> str_id, ImGuiPopupFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igIsPopupOpen_Str(ptr, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igIsPopupOpen_Str(ptr, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public static bool IsRectVisible(Vector2 size)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			byte b = ImGuiNative.igIsRectVisible_Nil(size);
			return b != 0;
		}

		public static bool IsRectVisible(Vector2 rect_min, Vector2 rect_max)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			byte b = ImGuiNative.igIsRectVisible_Vec2(rect_min, rect_max);
			return b != 0;
		}

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

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

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

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

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

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

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

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

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

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

		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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int* ptr3 = stackalloc int[items.Length];
			int num2 = 0;
			for (int i = 0; i < items.Length; i++)
			{
				string s = items[i];
				ptr3[i] = Encoding.UTF8.GetByteCount(s);
				num2 += ptr3[i] + 1;
			}
			byte* ptr4 = stackalloc byte[(int)(uint)num2];
			int num3 = 0;
			for (int j = 0; j < items.Length; j++)
			{
				string s2 = items[j];
				num3 += Util.GetUtf8(s2, ptr4 + num3, ptr3[j]);
				ptr4[num3++] = 0;
			}
			byte** ptr5 = stackalloc byte*[items.Length];
			num3 = 0;
			for (int k = 0; k < items.Length; k++)
			{
				ptr5[k] = ptr4 + num3;
				num3 += ptr3[k] + 1;
			}
			int height_in_items = -1;
			fixed (int* current_item2 = &current_item)
			{
				byte b = ImGuiNative.igListBox_Str_arr(ptr, current_item2, ptr5, items_count, height_in_items);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				return b != 0;
			}
		}

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

		public unsafe static void LoadIniSettingsFromDisk(ReadOnlySpan<char> ini_filename)
		{
			int num = 0;
			byte* ptr;
			if (ini_filename != null)
			{
				num = Encoding.UTF8.GetByteCount(ini_filename);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 LoadIniSettingsFromDisk(string ini_filename)
		{
			int num = 0;
			byte* ptr;
			if (ini_filename != null)
			{
				num = Encoding.UTF8.GetByteCount(ini_filename);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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(ReadOnlySpan<char> ini_data)
		{
			int num = 0;
			byte* ptr;
			if (ini_data != null)
			{
				num = Encoding.UTF8.GetByteCount(ini_data);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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)
		{
			int num = 0;
			byte* ptr;
			if (ini_data != null)
			{
				num = Encoding.UTF8.GetByteCount(ini_data);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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(ReadOnlySpan<char> ini_data, uint ini_size)
		{
			int num = 0;
			byte* ptr;
			if (ini_data != null)
			{
				num = Encoding.UTF8.GetByteCount(ini_data);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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(ReadOnlySpan<char> fmt)
		{
			int num = 0;
			byte* ptr;
			if (fmt != null)
			{
				num = Encoding.UTF8.GetByteCount(fmt);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(fmt, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			ImGuiNative.igLogText(ptr);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
		}

		public unsafe static void LogText(string fmt)
		{
			int num = 0;
			byte* ptr;
			if (fmt != null)
			{
				num = Encoding.UTF8.GetByteCount(fmt);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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()
		{
			int auto_open_depth = -1;
			ImGuiNative.igLogToClipboard(auto_open_depth);
		}

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

		public unsafe static void LogToFile()
		{
			int auto_open_depth = -1;
			byte* filename = null;
			ImGuiNative.igLogToFile(auto_open_depth, 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, ReadOnlySpan<char> filename)
		{
			int num = 0;
			byte* ptr;
			if (filename != null)
			{
				num = Encoding.UTF8.GetByteCount(filename);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 unsafe static void LogToFile(int auto_open_depth, string filename)
		{
			int num = 0;
			byte* ptr;
			if (filename != null)
			{
				num = Encoding.UTF8.GetByteCount(filename);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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()
		{
			int auto_open_depth = -1;
			ImGuiNative.igLogToTTY(auto_open_depth);
		}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		public unsafe static void OpenPopup(ReadOnlySpan<char> str_id)
		{
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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)
		{
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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(ReadOnlySpan<char> str_id, ImGuiPopupFlags popup_flags)
		{
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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(ReadOnlySpan<char> str_id)
		{
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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)
		{
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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(ReadOnlySpan<char> str_id, ImGuiPopupFlags popup_flags)
		{
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 OpenPopupOnItemClick(string str_id, ImGuiPopupFlags popup_flags)
		{
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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(ReadOnlySpan<char> label, ref float values, int values_count)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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)
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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(ReadOnlySpan<char> label, ref float values, int values_count, int values_offset)
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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(ReadOnlySpan<char> label, ref float values, int values_count, int values_offset, ReadOnlySpan<char> overlay_text)
		{
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (overlay_text != null)
			{
				num2 = Encoding.UTF8.GetByteCount(overlay_text);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(overlay_text, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = 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, ptr3, scale_min, scale_max, graph_size, stride);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
			}
		}

		public unsafe static void PlotHistogram(string label, ref float values, int values_count, int values_offset, string overlay_text)
		{
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (overlay_text != null)
			{
				num2 = Encoding.UTF8.GetByteCount(overlay_text);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(overlay_text, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = 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, ptr3, scale_min, scale_max, graph_size, stride);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
			}
		}

		public unsafe static void PlotHistogram(ReadOnlySpan<char> label, ref float values, int values_count, int values_offset, ReadOnlySpan<char> overlay_text, float scale_min)
		{
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (overlay_text != null)
			{
				num2 = Encoding.UTF8.GetByteCount(overlay_text);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(overlay_text, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = 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, ptr3, scale_min, scale_max, graph_size, stride);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
			}
		}

		public unsafe static void PlotHistogram(string label, ref float values, int values_count, int values_offset, string overlay_text, float scale_min)
		{
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (overlay_text != null)
			{
				num2 = Encoding.UTF8.GetByteCount(overlay_text);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(overlay_text, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = 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, ptr3, scale_min, scale_max, graph_size, stride);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
			}
		}

		public unsafe static void PlotHistogram(ReadOnlySpan<char> label, ref float values, int values_count, int values_offset, ReadOnlySpan<char> overlay_text, float scale_min, float scale_max)
		{
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (overlay_text != null)
			{
				num2 = Encoding.UTF8.GetByteCount(overlay_text);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(overlay_text, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			Vector2 graph_size = default(Vector2);
			int stride = 4;
			fixed (float* values2 = &values)
			{
				ImGuiNative.igPlotHistogram_FloatPtr(ptr, values2, values_count, values_offset, ptr3, scale_min, scale_max, graph_size, stride);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
			}
		}

		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)
		{
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (overlay_text != null)
			{
				num2 = Encoding.UTF8.GetByteCount(overlay_text);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(overlay_text, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			Vector2 graph_size = default(Vector2);
			int stride = 4;
			fixed (float* values2 = &values)
			{
				ImGuiNative.igPlotHistogram_FloatPtr(ptr, values2, values_count, values_offset, ptr3, scale_min, scale_max, graph_size, stride);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
			}
		}

		public unsafe static void PlotHistogram(ReadOnlySpan<char> label, ref float values, int values_count, int values_offset, ReadOnlySpan<char> overlay_text, float scale_min, float scale_max, Vector2 graph_size)
		{
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (overlay_text != null)
			{
				num2 = Encoding.UTF8.GetByteCount(overlay_text);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(overlay_text, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			int stride = 4;
			fixed (float* values2 = &values)
			{
				ImGuiNative.igPlotHistogram_FloatPtr(ptr, values2, values_count, values_offset, ptr3, scale_min, scale_max, graph_size, stride);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
			}
		}

		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)
		{
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (overlay_text != null)
			{
				num2 = Encoding.UTF8.GetByteCount(overlay_text);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(overlay_text, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			int stride = 4;
			fixed (float* values2 = &values)
			{
				ImGuiNative.igPlotHistogram_FloatPtr(ptr, values2, values_count, values_offset, ptr3, scale_min, scale_max, graph_size, stride);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
			}
		}

		public unsafe static void PlotHistogram(ReadOnlySpan<char> label, ref float values, int values_count, int values_offset, ReadOnlySpan<char> overlay_text, float scale_min, float scale_max, Vector2 graph_size, int stride)
		{
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (overlay_text != null)
			{
				num2 = Encoding.UTF8.GetByteCount(overlay_text);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(overlay_text, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (float* values2 = &values)
			{
				ImGuiNative.igPlotHistogram_FloatPtr(ptr, values2, values_count, values_offset, ptr3, scale_min, scale_max, graph_size, stride);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
			}
		}

		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)
		{
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (overlay_text != null)
			{
				num2 = Encoding.UTF8.GetByteCount(overlay_text);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(overlay_text, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (float* values2 = &values)
			{
				ImGuiNative.igPlotHistogram_FloatPtr(ptr, values2, values_count, values_offset, ptr3, scale_min, scale_max, graph_size, stride);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
			}
		}

		public unsafe static void PlotLines(ReadOnlySpan<char> label, ref float values, int values_count)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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)
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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(ReadOnlySpan<char> label, ref float values, int values_count, int values_offset)
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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(ReadOnlySpan<char> label, ref float values, int values_count, int values_offset, ReadOnlySpan<char> overlay_text)
		{
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (overlay_text != null)
			{
				num2 = Encoding.UTF8.GetByteCount(overlay_text);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(overlay_text, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = 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, ptr3, scale_min, scale_max, graph_size, stride);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
			}
		}

		public unsafe static void PlotLines(string label, ref float values, int values_count, int values_offset, string overlay_text)
		{
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (overlay_text != null)
			{
				num2 = Encoding.UTF8.GetByteCount(overlay_text);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(overlay_text, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = 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, ptr3, scale_min, scale_max, graph_size, stride);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
			}
		}

		public unsafe static void PlotLines(ReadOnlySpan<char> label, ref float values, int values_count, int values_offset, ReadOnlySpan<char> overlay_text, float scale_min)
		{
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (overlay_text != null)
			{
				num2 = Encoding.UTF8.GetByteCount(overlay_text);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(overlay_text, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = 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, ptr3, scale_min, scale_max, graph_size, stride);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
			}
		}

		public unsafe static void PlotLines(string label, ref float values, int values_count, int values_offset, string overlay_text, float scale_min)
		{
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (overlay_text != null)
			{
				num2 = Encoding.UTF8.GetByteCount(overlay_text);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(overlay_text, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = 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, ptr3, scale_min, scale_max, graph_size, stride);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
			}
		}

		public unsafe static void PlotLines(ReadOnlySpan<char> label, ref float values, int values_count, int values_offset, ReadOnlySpan<char> overlay_text, float scale_min, float scale_max)
		{
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (overlay_text != null)
			{
				num2 = Encoding.UTF8.GetByteCount(overlay_text);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(overlay_text, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			Vector2 graph_size = default(Vector2);
			int stride = 4;
			fixed (float* values2 = &values)
			{
				ImGuiNative.igPlotLines_FloatPtr(ptr, values2, values_count, values_offset, ptr3, scale_min, scale_max, graph_size, stride);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
			}
		}

		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)
		{
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (overlay_text != null)
			{
				num2 = Encoding.UTF8.GetByteCount(overlay_text);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(overlay_text, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			Vector2 graph_size = default(Vector2);
			int stride = 4;
			fixed (float* values2 = &values)
			{
				ImGuiNative.igPlotLines_FloatPtr(ptr, values2, values_count, values_offset, ptr3, scale_min, scale_max, graph_size, stride);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
			}
		}

		public unsafe static void PlotLines(ReadOnlySpan<char> label, ref float values, int values_count, int values_offset, ReadOnlySpan<char> overlay_text, float scale_min, float scale_max, Vector2 graph_size)
		{
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (overlay_text != null)
			{
				num2 = Encoding.UTF8.GetByteCount(overlay_text);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(overlay_text, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			int stride = 4;
			fixed (float* values2 = &values)
			{
				ImGuiNative.igPlotLines_FloatPtr(ptr, values2, values_count, values_offset, ptr3, scale_min, scale_max, graph_size, stride);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
			}
		}

		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)
		{
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (overlay_text != null)
			{
				num2 = Encoding.UTF8.GetByteCount(overlay_text);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(overlay_text, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			int stride = 4;
			fixed (float* values2 = &values)
			{
				ImGuiNative.igPlotLines_FloatPtr(ptr, values2, values_count, values_offset, ptr3, scale_min, scale_max, graph_size, stride);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
			}
		}

		public unsafe static void PlotLines(ReadOnlySpan<char> label, ref float values, int values_count, int values_offset, ReadOnlySpan<char> overlay_text, float scale_min, float scale_max, Vector2 graph_size, int stride)
		{
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (overlay_text != null)
			{
				num2 = Encoding.UTF8.GetByteCount(overlay_text);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(overlay_text, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (float* values2 = &values)
			{
				ImGuiNative.igPlotLines_FloatPtr(ptr, values2, values_count, values_offset, ptr3, scale_min, scale_max, graph_size, stride);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
			}
		}

		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)
		{
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (overlay_text != null)
			{
				num2 = Encoding.UTF8.GetByteCount(overlay_text);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(overlay_text, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (float* values2 = &values)
			{
				ImGuiNative.igPlotLines_FloatPtr(ptr, values2, values_count, values_offset, ptr3, scale_min, scale_max, graph_size, stride);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
			}
		}

		public static void PopClipRect()
		{
			ImGuiNative.igPopClipRect();
		}

		public static void PopFont()
		{
			ImGuiNative.igPopFont();
		}

		public static void PopID()
		{
			ImGuiNative.igPopID();
		}

		public static void PopItemFlag()
		{
			ImGuiNative.igPopItemFlag();
		}

		public static void PopItemWidth()
		{
			ImGuiNative.igPopItemWidth();
		}

		public static void PopStyleColor()
		{
			int count = 1;
			ImGuiNative.igPopStyleColor(count);
		}

		public static void PopStyleColor(int count)
		{
			ImGuiNative.igPopStyleColor(count);
		}

		public static void PopStyleVar()
		{
			int count = 1;
			ImGuiNative.igPopStyleVar(count);
		}

		public static void PopStyleVar(int count)
		{
			ImGuiNative.igPopStyleVar(count);
		}

		public static void PopTextWrapPos()
		{
			ImGuiNative.igPopTextWrapPos();
		}

		public unsafe static void ProgressBar(float fraction)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			Vector2 size_arg = default(Vector2);
			((Vector2)(ref size_arg))..ctor(float.MaxValue, 0f);
			byte* overlay = null;
			ImGuiNative.igProgressBar(fraction, size_arg, overlay);
		}

		public unsafe static void ProgressBar(float fraction, Vector2 size_arg)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			byte* overlay = null;
			ImGuiNative.igProgressBar(fraction, size_arg, overlay);
		}

		public unsafe static void ProgressBar(float fraction, Vector2 size_arg, ReadOnlySpan<char> overlay)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (overlay != null)
			{
				num = Encoding.UTF8.GetByteCount(overlay);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 unsafe static void ProgressBar(float fraction, Vector2 size_arg, string overlay)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (overlay != null)
			{
				num = Encoding.UTF8.GetByteCount(overlay);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 PushClipRect(Vector2 clip_rect_min, Vector2 clip_rect_max, bool intersect_with_current_clip_rect)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			ImFont* nativePtr = font.NativePtr;
			ImGuiNative.igPushFont(nativePtr);
		}

		public unsafe static void PushID(ReadOnlySpan<char> str_id)
		{
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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(string str_id)
		{
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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)
		{
			void* ptr_id2 = ptr_id.ToPointer();
			ImGuiNative.igPushID_Ptr(ptr_id2);
		}

		public static void PushID(int int_id)
		{
			ImGuiNative.igPushID_Int(int_id);
		}

		public static void PushItemFlag(ImGuiItemFlags option, bool enabled)
		{
			byte enabled2 = (byte)(enabled ? 1 : 0);
			ImGuiNative.igPushItemFlag(option, enabled2);
		}

		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)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			ImGuiNative.igPushStyleVar_Vec2(idx, val);
		}

		public static void PushTextWrapPos()
		{
			float wrap_local_pos_x = 0f;
			ImGuiNative.igPushTextWrapPos(wrap_local_pos_x);
		}

		public static void PushTextWrapPos(float wrap_local_pos_x)
		{
			ImGuiNative.igPushTextWrapPos(wrap_local_pos_x);
		}

		public unsafe static bool RadioButton(ReadOnlySpan<char> label, bool active)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte active2 = (byte)(active ? 1 : 0);
			byte b = ImGuiNative.igRadioButton_Bool(ptr, active2);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

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

		public unsafe static bool RadioButton(ReadOnlySpan<char> label, ref int v, int v_button)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igRadioButton_IntPtr(ptr, v2, v_button);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igRadioButton_IntPtr(ptr, v2, v_button);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				return b != 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()
		{
			ImGuiMouseButton button = ImGuiMouseButton.Left;
			ImGuiNative.igResetMouseDragDelta(button);
		}

		public static void ResetMouseDragDelta(ImGuiMouseButton button)
		{
			ImGuiNative.igResetMouseDragDelta(button);
		}

		public static void SameLine()
		{
			float offset_from_start_x = 0f;
			float spacing = -1f;
			ImGuiNative.igSameLine(offset_from_start_x, 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(ReadOnlySpan<char> ini_filename)
		{
			int num = 0;
			byte* ptr;
			if (ini_filename != null)
			{
				num = Encoding.UTF8.GetByteCount(ini_filename);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 void SaveIniSettingsToDisk(string ini_filename)
		{
			int num = 0;
			byte* ptr;
			if (ini_filename != null)
			{
				num = Encoding.UTF8.GetByteCount(ini_filename);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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;
			byte* ptr = ImGuiNative.igSaveIniSettingsToMemory(out_ini_size);
			return Util.StringFromPtr(ptr);
		}

		public unsafe static string SaveIniSettingsToMemory(out uint out_ini_size)
		{
			fixed (uint* out_ini_size2 = &out_ini_size)
			{
				byte* ptr = ImGuiNative.igSaveIniSettingsToMemory(out_ini_size2);
				return Util.StringFromPtr(ptr);
			}
		}

		public unsafe static bool Selectable(ReadOnlySpan<char> label)
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte selected = 0;
			ImGuiSelectableFlags flags = ImGuiSelectableFlags.None;
			byte b = ImGuiNative.igSelectable_Bool(ptr, selected, flags, default(Vector2));
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool Selectable(string label)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte selected = 0;
			ImGuiSelectableFlags flags = ImGuiSelectableFlags.None;
			byte b = ImGuiNative.igSelectable_Bool(ptr, selected, flags, default(Vector2));
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool Selectable(ReadOnlySpan<char> label, bool selected)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte selected2 = (byte)(selected ? 1 : 0);
			ImGuiSelectableFlags flags = ImGuiSelectableFlags.None;
			byte b = ImGuiNative.igSelectable_Bool(ptr, selected2, flags, default(Vector2));
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool Selectable(string label, bool selected)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte selected2 = (byte)(selected ? 1 : 0);
			ImGuiSelectableFlags flags = ImGuiSelectableFlags.None;
			byte b = ImGuiNative.igSelectable_Bool(ptr, selected2, flags, default(Vector2));
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool Selectable(ReadOnlySpan<char> label, bool selected, ImGuiSelectableFlags flags)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte selected2 = (byte)(selected ? 1 : 0);
			byte b = ImGuiNative.igSelectable_Bool(ptr, selected2, flags, default(Vector2));
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool Selectable(string label, bool selected, ImGuiSelectableFlags flags)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte selected2 = (byte)(selected ? 1 : 0);
			byte b = ImGuiNative.igSelectable_Bool(ptr, selected2, flags, default(Vector2));
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool Selectable(ReadOnlySpan<char> label, bool selected, ImGuiSelectableFlags flags, Vector2 size)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte selected2 = (byte)(selected ? 1 : 0);
			byte b = ImGuiNative.igSelectable_Bool(ptr, selected2, flags, size);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool Selectable(string label, bool selected, ImGuiSelectableFlags flags, Vector2 size)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte selected2 = (byte)(selected ? 1 : 0);
			byte b = ImGuiNative.igSelectable_Bool(ptr, selected2, flags, size);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool Selectable(ReadOnlySpan<char> label, ref bool p_selected)
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b2 = ImGuiNative.igSelectable_BoolPtr(ptr, p_selected2, flags, default(Vector2));
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			p_selected = b != 0;
			return b2 != 0;
		}

		public unsafe static bool Selectable(string label, ref bool p_selected)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b2 = ImGuiNative.igSelectable_BoolPtr(ptr, p_selected2, flags, default(Vector2));
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			p_selected = b != 0;
			return b2 != 0;
		}

		public unsafe static bool Selectable(ReadOnlySpan<char> label, ref bool p_selected, ImGuiSelectableFlags flags)
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b2 = ImGuiNative.igSelectable_BoolPtr(ptr, p_selected2, flags, default(Vector2));
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			p_selected = b != 0;
			return b2 != 0;
		}

		public unsafe static bool Selectable(string label, ref bool p_selected, ImGuiSelectableFlags flags)
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b2 = ImGuiNative.igSelectable_BoolPtr(ptr, p_selected2, flags, default(Vector2));
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			p_selected = b != 0;
			return b2 != 0;
		}

		public unsafe static bool Selectable(ReadOnlySpan<char> label, ref bool p_selected, ImGuiSelectableFlags flags, Vector2 size)
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b2 = ImGuiNative.igSelectable_BoolPtr(ptr, p_selected2, flags, size);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			p_selected = b != 0;
			return b2 != 0;
		}

		public unsafe static bool Selectable(string label, ref bool p_selected, ImGuiSelectableFlags flags, Vector2 size)
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b2 = ImGuiNative.igSelectable_BoolPtr(ptr, p_selected2, flags, size);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			p_selected = b != 0;
			return b2 != 0;
		}

		public static void Separator()
		{
			ImGuiNative.igSeparator();
		}

		public unsafe static void SeparatorText(ReadOnlySpan<char> label)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			ImGuiNative.igSeparatorText(ptr);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
		}

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

		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(ReadOnlySpan<char> text)
		{
			int num = 0;
			byte* ptr;
			if (text != null)
			{
				num = Encoding.UTF8.GetByteCount(text);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(text, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			ImGuiNative.igSetClipboardText(ptr);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
		}

		public unsafe static void SetClipboardText(string text)
		{
			int num = 0;
			byte* ptr;
			if (text != null)
			{
				num = Encoding.UTF8.GetByteCount(text);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			ImGuiNative.igSetCursorScreenPos(pos);
		}

		public unsafe static bool SetDragDropPayload(ReadOnlySpan<char> type, IntPtr data, uint sz)
		{
			int num = 0;
			byte* ptr;
			if (type != null)
			{
				num = Encoding.UTF8.GetByteCount(type);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(type, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			void* data2 = data.ToPointer();
			ImGuiCond cond = ImGuiCond.None;
			byte b = ImGuiNative.igSetDragDropPayload(ptr, data2, sz, cond);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool SetDragDropPayload(string type, IntPtr data, uint sz)
		{
			int num = 0;
			byte* ptr;
			if (type != null)
			{
				num = Encoding.UTF8.GetByteCount(type);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(type, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			void* data2 = data.ToPointer();
			ImGuiCond cond = ImGuiCond.None;
			byte b = ImGuiNative.igSetDragDropPayload(ptr, data2, sz, cond);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool SetDragDropPayload(ReadOnlySpan<char> type, IntPtr data, uint sz, ImGuiCond cond)
		{
			int num = 0;
			byte* ptr;
			if (type != null)
			{
				num = Encoding.UTF8.GetByteCount(type);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(type, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			void* data2 = data.ToPointer();
			byte b = ImGuiNative.igSetDragDropPayload(ptr, data2, sz, cond);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(type, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			void* data2 = data.ToPointer();
			byte b = ImGuiNative.igSetDragDropPayload(ptr, data2, sz, cond);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public static void SetItemDefaultFocus()
		{
			ImGuiNative.igSetItemDefaultFocus();
		}

		public static void SetItemKeyOwner(ImGuiKey key)
		{
			ImGuiNative.igSetItemKeyOwner_Nil(key);
		}

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

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

		public static void SetKeyboardFocusHere()
		{
			int offset = 0;
			ImGuiNative.igSetKeyboardFocusHere(offset);
		}

		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)
		{
			byte want_capture_keyboard2 = (byte)(want_capture_keyboard ? 1 : 0);
			ImGuiNative.igSetNextFrameWantCaptureKeyboard(want_capture_keyboard2);
		}

		public static void SetNextFrameWantCaptureMouse(bool want_capture_mouse)
		{
			byte want_capture_mouse2 = (byte)(want_capture_mouse ? 1 : 0);
			ImGuiNative.igSetNextFrameWantCaptureMouse(want_capture_mouse2);
		}

		public static void SetNextItemAllowOverlap()
		{
			ImGuiNative.igSetNextItemAllowOverlap();
		}

		public static void SetNextItemOpen(bool is_open)
		{
			byte is_open2 = (byte)(is_open ? 1 : 0);
			ImGuiCond cond = ImGuiCond.None;
			ImGuiNative.igSetNextItemOpen(is_open2, cond);
		}

		public static void SetNextItemOpen(bool is_open, ImGuiCond cond)
		{
			byte is_open2 = (byte)(is_open ? 1 : 0);
			ImGuiNative.igSetNextItemOpen(is_open2, cond);
		}

		public static void SetNextItemSelectionUserData(long selection_user_data)
		{
			ImGuiNative.igSetNextItemSelectionUserData(selection_user_data);
		}

		public static void SetNextItemShortcut(ImGuiKey key_chord)
		{
			ImGuiInputFlags flags = ImGuiInputFlags.None;
			ImGuiNative.igSetNextItemShortcut(key_chord, flags);
		}

		public static void SetNextItemShortcut(ImGuiKey key_chord, ImGuiInputFlags flags)
		{
			ImGuiNative.igSetNextItemShortcut(key_chord, flags);
		}

		public static void SetNextItemStorageID(uint storage_id)
		{
			ImGuiNative.igSetNextItemStorageID(storage_id);
		}

		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)
		{
			ImGuiWindowClass* nativePtr = window_class.NativePtr;
			ImGuiNative.igSetNextWindowClass(nativePtr);
		}

		public static void SetNextWindowCollapsed(bool collapsed)
		{
			byte collapsed2 = (byte)(collapsed ? 1 : 0);
			ImGuiCond cond = ImGuiCond.None;
			ImGuiNative.igSetNextWindowCollapsed(collapsed2, cond);
		}

		public static void SetNextWindowCollapsed(bool collapsed, ImGuiCond cond)
		{
			byte collapsed2 = (byte)(collapsed ? 1 : 0);
			ImGuiNative.igSetNextWindowCollapsed(collapsed2, cond);
		}

		public static void SetNextWindowContentSize(Vector2 size)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			ImGuiCond cond = ImGuiCond.None;
			ImGuiNative.igSetNextWindowPos(pos, cond, default(Vector2));
		}

		public static void SetNextWindowPos(Vector2 pos, ImGuiCond cond)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			ImGuiNative.igSetNextWindowPos(pos, cond, default(Vector2));
		}

		public static void SetNextWindowPos(Vector2 pos, ImGuiCond cond, Vector2 pivot)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			ImGuiNative.igSetNextWindowPos(pos, cond, pivot);
		}

		public static void SetNextWindowScroll(Vector2 scroll)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			ImGuiNative.igSetNextWindowScroll(scroll);
		}

		public static void SetNextWindowSize(Vector2 size)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			ImGuiCond cond = ImGuiCond.None;
			ImGuiNative.igSetNextWindowSize(size, cond);
		}

		public static void SetNextWindowSize(Vector2 size, ImGuiCond cond)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			ImGuiNative.igSetNextWindowSize(size, cond);
		}

		public unsafe static void SetNextWindowSizeConstraints(Vector2 size_min, Vector2 size_max)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			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()
		{
			float center_x_ratio = 0.5f;
			ImGuiNative.igSetScrollHereX(center_x_ratio);
		}

		public static void SetScrollHereX(float center_x_ratio)
		{
			ImGuiNative.igSetScrollHereX(center_x_ratio);
		}

		public static void SetScrollHereY()
		{
			float center_y_ratio = 0.5f;
			ImGuiNative.igSetScrollHereY(center_y_ratio);
		}

		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)
		{
			ImGuiStorage* nativePtr = storage.NativePtr;
			ImGuiNative.igSetStateStorage(nativePtr);
		}

		public unsafe static void SetTabItemClosed(ReadOnlySpan<char> 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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(ReadOnlySpan<char> fmt)
		{
			int num = 0;
			byte* ptr;
			if (fmt != null)
			{
				num = Encoding.UTF8.GetByteCount(fmt);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(fmt, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			ImGuiNative.igSetTooltip(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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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)
		{
			byte collapsed2 = (byte)(collapsed ? 1 : 0);
			ImGuiCond cond = ImGuiCond.None;
			ImGuiNative.igSetWindowCollapsed_Bool(collapsed2, cond);
		}

		public static void SetWindowCollapsed(bool collapsed, ImGuiCond cond)
		{
			byte collapsed2 = (byte)(collapsed ? 1 : 0);
			ImGuiNative.igSetWindowCollapsed_Bool(collapsed2, cond);
		}

		public unsafe static void SetWindowCollapsed(ReadOnlySpan<char> name, bool collapsed)
		{
			int num = 0;
			byte* ptr;
			if (name != null)
			{
				num = Encoding.UTF8.GetByteCount(name);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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)
		{
			int num = 0;
			byte* ptr;
			if (name != null)
			{
				num = Encoding.UTF8.GetByteCount(name);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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(ReadOnlySpan<char> name, bool collapsed, ImGuiCond cond)
		{
			int num = 0;
			byte* ptr;
			if (name != null)
			{
				num = Encoding.UTF8.GetByteCount(name);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 unsafe static void SetWindowCollapsed(string name, bool collapsed, ImGuiCond cond)
		{
			int num = 0;
			byte* ptr;
			if (name != null)
			{
				num = Encoding.UTF8.GetByteCount(name);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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(ReadOnlySpan<char> name)
		{
			int num = 0;
			byte* ptr;
			if (name != null)
			{
				num = Encoding.UTF8.GetByteCount(name);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(name, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			ImGuiNative.igSetWindowFocus_Str(ptr);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
		}

		public unsafe static void SetWindowFocus(string name)
		{
			int num = 0;
			byte* ptr;
			if (name != null)
			{
				num = Encoding.UTF8.GetByteCount(name);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			ImGuiCond cond = ImGuiCond.None;
			ImGuiNative.igSetWindowPos_Vec2(pos, cond);
		}

		public static void SetWindowPos(Vector2 pos, ImGuiCond cond)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			ImGuiNative.igSetWindowPos_Vec2(pos, cond);
		}

		public unsafe static void SetWindowPos(ReadOnlySpan<char> name, Vector2 pos)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (name != null)
			{
				num = Encoding.UTF8.GetByteCount(name);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (name != null)
			{
				num = Encoding.UTF8.GetByteCount(name);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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(ReadOnlySpan<char> name, Vector2 pos, ImGuiCond cond)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (name != null)
			{
				num = Encoding.UTF8.GetByteCount(name);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 unsafe static void SetWindowPos(string name, Vector2 pos, ImGuiCond cond)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (name != null)
			{
				num = Encoding.UTF8.GetByteCount(name);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			ImGuiCond cond = ImGuiCond.None;
			ImGuiNative.igSetWindowSize_Vec2(size, cond);
		}

		public static void SetWindowSize(Vector2 size, ImGuiCond cond)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			ImGuiNative.igSetWindowSize_Vec2(size, cond);
		}

		public unsafe static void SetWindowSize(ReadOnlySpan<char> name, Vector2 size)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (name != null)
			{
				num = Encoding.UTF8.GetByteCount(name);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (name != null)
			{
				num = Encoding.UTF8.GetByteCount(name);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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(ReadOnlySpan<char> name, Vector2 size, ImGuiCond cond)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (name != null)
			{
				num = Encoding.UTF8.GetByteCount(name);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 SetWindowSize(string name, Vector2 size, ImGuiCond cond)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (name != null)
			{
				num = Encoding.UTF8.GetByteCount(name);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 static bool Shortcut(ImGuiKey key_chord)
		{
			ImGuiInputFlags flags = ImGuiInputFlags.None;
			byte b = ImGuiNative.igShortcut_Nil(key_chord, flags);
			return b != 0;
		}

		public static bool Shortcut(ImGuiKey key_chord, ImGuiInputFlags flags)
		{
			byte b = ImGuiNative.igShortcut_Nil(key_chord, flags);
			return b != 0;
		}

		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);
			byte* p_open2 = &b;
			ImGuiNative.igShowAboutWindow(p_open2);
			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);
			byte* p_open2 = &b;
			ImGuiNative.igShowDebugLogWindow(p_open2);
			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);
			byte* p_open2 = &b;
			ImGuiNative.igShowDemoWindow(p_open2);
			p_open = b != 0;
		}

		public unsafe static void ShowFontSelector(ReadOnlySpan<char> label)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 ShowFontSelector(string label)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 ShowIDStackToolWindow()
		{
			byte* p_open = null;
			ImGuiNative.igShowIDStackToolWindow(p_open);
		}

		public unsafe static void ShowIDStackToolWindow(ref bool p_open)
		{
			byte b = (byte)(p_open ? 1 : 0);
			byte* p_open2 = &b;
			ImGuiNative.igShowIDStackToolWindow(p_open2);
			p_open = b != 0;
		}

		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);
			byte* p_open2 = &b;
			ImGuiNative.igShowMetricsWindow(p_open2);
			p_open = b != 0;
		}

		public unsafe static void ShowStyleEditor()
		{
			ImGuiStyle* @ref = null;
			ImGuiNative.igShowStyleEditor(@ref);
		}

		public unsafe static void ShowStyleEditor(ImGuiStylePtr @ref)
		{
			ImGuiStyle* nativePtr = @ref.NativePtr;
			ImGuiNative.igShowStyleEditor(nativePtr);
		}

		public unsafe static bool ShowStyleSelector(ReadOnlySpan<char> label)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igShowStyleSelector(ptr);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool ShowStyleSelector(string label)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igShowStyleSelector(ptr);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public static void ShowUserGuide()
		{
			ImGuiNative.igShowUserGuide();
		}

		public unsafe static bool SliderAngle(ReadOnlySpan<char> label, ref float v_rad)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.0f deg", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (float* v_rad2 = &v_rad)
			{
				byte b = ImGuiNative.igSliderAngle(ptr, v_rad2, v_degrees_min, v_degrees_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool SliderAngle(string label, ref float v_rad)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.0f deg", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (float* v_rad2 = &v_rad)
			{
				byte b = ImGuiNative.igSliderAngle(ptr, v_rad2, v_degrees_min, v_degrees_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool SliderAngle(ReadOnlySpan<char> label, ref float v_rad, float v_degrees_min)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.0f deg", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (float* v_rad2 = &v_rad)
			{
				byte b = ImGuiNative.igSliderAngle(ptr, v_rad2, v_degrees_min, v_degrees_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.0f deg", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (float* v_rad2 = &v_rad)
			{
				byte b = ImGuiNative.igSliderAngle(ptr, v_rad2, v_degrees_min, v_degrees_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool SliderAngle(ReadOnlySpan<char> 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%.0f deg");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.0f deg", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (float* v_rad2 = &v_rad)
			{
				byte b = ImGuiNative.igSliderAngle(ptr, v_rad2, v_degrees_min, v_degrees_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%.0f deg");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.0f deg", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (float* v_rad2 = &v_rad)
			{
				byte b = ImGuiNative.igSliderAngle(ptr, v_rad2, v_degrees_min, v_degrees_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool SliderAngle(ReadOnlySpan<char> label, ref float v_rad, float v_degrees_min, float v_degrees_max, ReadOnlySpan<char> format)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (float* v_rad2 = &v_rad)
			{
				byte b = ImGuiNative.igSliderAngle(ptr, v_rad2, v_degrees_min, v_degrees_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (float* v_rad2 = &v_rad)
			{
				byte b = ImGuiNative.igSliderAngle(ptr, v_rad2, v_degrees_min, v_degrees_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool SliderAngle(ReadOnlySpan<char> label, ref float v_rad, float v_degrees_min, float v_degrees_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (float* v_rad2 = &v_rad)
			{
				byte b = ImGuiNative.igSliderAngle(ptr, v_rad2, v_degrees_min, v_degrees_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (float* v_rad2 = &v_rad)
			{
				byte b = ImGuiNative.igSliderAngle(ptr, v_rad2, v_degrees_min, v_degrees_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool SliderFloat(ReadOnlySpan<char> label, ref float v, float v_min, float v_max)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%.3f");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (float* v2 = &v)
			{
				byte b = ImGuiNative.igSliderFloat(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%.3f");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (float* v2 = &v)
			{
				byte b = ImGuiNative.igSliderFloat(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool SliderFloat(ReadOnlySpan<char> label, ref float v, float v_min, float v_max, ReadOnlySpan<char> format)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (float* v2 = &v)
			{
				byte b = ImGuiNative.igSliderFloat(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (float* v2 = &v)
			{
				byte b = ImGuiNative.igSliderFloat(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool SliderFloat(ReadOnlySpan<char> label, ref float v, float v_min, float v_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (float* v2 = &v)
			{
				byte b = ImGuiNative.igSliderFloat(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (float* v2 = &v)
			{
				byte b = ImGuiNative.igSliderFloat(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool SliderFloat2(ReadOnlySpan<char> label, ref Vector2 v, float v_min, float v_max)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%.3f");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (Vector2* v2 = &v)
			{
				byte b = ImGuiNative.igSliderFloat2(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%.3f");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (Vector2* v2 = &v)
			{
				byte b = ImGuiNative.igSliderFloat2(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool SliderFloat2(ReadOnlySpan<char> label, ref Vector2 v, float v_min, float v_max, ReadOnlySpan<char> format)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (Vector2* v2 = &v)
			{
				byte b = ImGuiNative.igSliderFloat2(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (Vector2* v2 = &v)
			{
				byte b = ImGuiNative.igSliderFloat2(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool SliderFloat2(ReadOnlySpan<char> label, ref Vector2 v, float v_min, float v_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (Vector2* v2 = &v)
			{
				byte b = ImGuiNative.igSliderFloat2(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (Vector2* v2 = &v)
			{
				byte b = ImGuiNative.igSliderFloat2(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool SliderFloat3(ReadOnlySpan<char> label, ref Vector3 v, float v_min, float v_max)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%.3f");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (Vector3* v2 = &v)
			{
				byte b = ImGuiNative.igSliderFloat3(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%.3f");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (Vector3* v2 = &v)
			{
				byte b = ImGuiNative.igSliderFloat3(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool SliderFloat3(ReadOnlySpan<char> label, ref Vector3 v, float v_min, float v_max, ReadOnlySpan<char> format)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (Vector3* v2 = &v)
			{
				byte b = ImGuiNative.igSliderFloat3(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (Vector3* v2 = &v)
			{
				byte b = ImGuiNative.igSliderFloat3(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool SliderFloat3(ReadOnlySpan<char> label, ref Vector3 v, float v_min, float v_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (Vector3* v2 = &v)
			{
				byte b = ImGuiNative.igSliderFloat3(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (Vector3* v2 = &v)
			{
				byte b = ImGuiNative.igSliderFloat3(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool SliderFloat4(ReadOnlySpan<char> label, ref Vector4 v, float v_min, float v_max)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%.3f");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (Vector4* v2 = &v)
			{
				byte b = ImGuiNative.igSliderFloat4(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%.3f");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (Vector4* v2 = &v)
			{
				byte b = ImGuiNative.igSliderFloat4(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool SliderFloat4(ReadOnlySpan<char> label, ref Vector4 v, float v_min, float v_max, ReadOnlySpan<char> format)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (Vector4* v2 = &v)
			{
				byte b = ImGuiNative.igSliderFloat4(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (Vector4* v2 = &v)
			{
				byte b = ImGuiNative.igSliderFloat4(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool SliderFloat4(ReadOnlySpan<char> label, ref Vector4 v, float v_min, float v_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (Vector4* v2 = &v)
			{
				byte b = ImGuiNative.igSliderFloat4(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (Vector4* v2 = &v)
			{
				byte b = ImGuiNative.igSliderFloat4(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool SliderInt(ReadOnlySpan<char> label, ref int v, int v_min, int v_max)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%d");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igSliderInt(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%d");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igSliderInt(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool SliderInt(ReadOnlySpan<char> label, ref int v, int v_min, int v_max, ReadOnlySpan<char> format)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igSliderInt(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igSliderInt(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool SliderInt(ReadOnlySpan<char> label, ref int v, int v_min, int v_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igSliderInt(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igSliderInt(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool SliderInt2(ReadOnlySpan<char> label, ref int v, int v_min, int v_max)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%d");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igSliderInt2(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%d");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igSliderInt2(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool SliderInt2(ReadOnlySpan<char> label, ref int v, int v_min, int v_max, ReadOnlySpan<char> format)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igSliderInt2(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igSliderInt2(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool SliderInt2(ReadOnlySpan<char> label, ref int v, int v_min, int v_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igSliderInt2(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igSliderInt2(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool SliderInt3(ReadOnlySpan<char> label, ref int v, int v_min, int v_max)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%d");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igSliderInt3(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%d");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igSliderInt3(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool SliderInt3(ReadOnlySpan<char> label, ref int v, int v_min, int v_max, ReadOnlySpan<char> format)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igSliderInt3(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igSliderInt3(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool SliderInt3(ReadOnlySpan<char> label, ref int v, int v_min, int v_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igSliderInt3(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igSliderInt3(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool SliderInt4(ReadOnlySpan<char> label, ref int v, int v_min, int v_max)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%d");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igSliderInt4(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%d");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igSliderInt4(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool SliderInt4(ReadOnlySpan<char> label, ref int v, int v_min, int v_max, ReadOnlySpan<char> format)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igSliderInt4(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igSliderInt4(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool SliderInt4(ReadOnlySpan<char> label, ref int v, int v_min, int v_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igSliderInt4(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igSliderInt4(ptr, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool SliderScalar(ReadOnlySpan<char> 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igSliderScalar(ptr, data_type, p_data2, p_min2, p_max2, format, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igSliderScalar(ptr, data_type, p_data2, p_min2, p_max2, format, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool SliderScalar(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, IntPtr p_min, IntPtr p_max, ReadOnlySpan<char> format)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			byte b = ImGuiNative.igSliderScalar(ptr, data_type, p_data2, p_min2, p_max2, ptr3, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr3);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			byte b = ImGuiNative.igSliderScalar(ptr, data_type, p_data2, p_min2, p_max2, ptr3, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr3);
			}
			return b != 0;
		}

		public unsafe static bool SliderScalar(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, IntPtr p_min, IntPtr p_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			byte b = ImGuiNative.igSliderScalar(ptr, data_type, p_data2, p_min2, p_max2, ptr3, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr3);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			byte b = ImGuiNative.igSliderScalar(ptr, data_type, p_data2, p_min2, p_max2, ptr3, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr3);
			}
			return b != 0;
		}

		public unsafe static bool SliderScalarN(ReadOnlySpan<char> 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igSliderScalarN(ptr, data_type, p_data2, components, p_min2, p_max2, format, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igSliderScalarN(ptr, data_type, p_data2, components, p_min2, p_max2, format, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool SliderScalarN(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, int components, IntPtr p_min, IntPtr p_max, ReadOnlySpan<char> format)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			byte b = ImGuiNative.igSliderScalarN(ptr, data_type, p_data2, components, p_min2, p_max2, ptr3, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr3);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			byte b = ImGuiNative.igSliderScalarN(ptr, data_type, p_data2, components, p_min2, p_max2, ptr3, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr3);
			}
			return b != 0;
		}

		public unsafe static bool SliderScalarN(ReadOnlySpan<char> label, ImGuiDataType data_type, IntPtr p_data, int components, IntPtr p_min, IntPtr p_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			byte b = ImGuiNative.igSliderScalarN(ptr, data_type, p_data2, components, p_min2, p_max2, ptr3, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr3);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			byte b = ImGuiNative.igSliderScalarN(ptr, data_type, p_data2, components, p_min2, p_max2, ptr3, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr3);
			}
			return b != 0;
		}

		public unsafe static bool SmallButton(ReadOnlySpan<char> label)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igSmallButton(ptr);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool SmallButton(string label)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igSmallButton(ptr);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 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)
		{
			ImGuiStyle* nativePtr = dst.NativePtr;
			ImGuiNative.igStyleColorsClassic(nativePtr);
		}

		public unsafe static void StyleColorsDark()
		{
			ImGuiStyle* dst = null;
			ImGuiNative.igStyleColorsDark(dst);
		}

		public unsafe static void StyleColorsDark(ImGuiStylePtr dst)
		{
			ImGuiStyle* nativePtr = dst.NativePtr;
			ImGuiNative.igStyleColorsDark(nativePtr);
		}

		public unsafe static void StyleColorsLight()
		{
			ImGuiStyle* dst = null;
			ImGuiNative.igStyleColorsLight(dst);
		}

		public unsafe static void StyleColorsLight(ImGuiStylePtr dst)
		{
			ImGuiStyle* nativePtr = dst.NativePtr;
			ImGuiNative.igStyleColorsLight(nativePtr);
		}

		public unsafe static bool TabItemButton(ReadOnlySpan<char> label)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			ImGuiTabItemFlags flags = ImGuiTabItemFlags.None;
			byte b = ImGuiNative.igTabItemButton(ptr, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

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

		public unsafe static bool TabItemButton(ReadOnlySpan<char> label, ImGuiTabItemFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igTabItemButton(ptr, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool TabItemButton(string label, ImGuiTabItemFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igTabItemButton(ptr, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public static void TableAngledHeadersRow()
		{
			ImGuiNative.igTableAngledHeadersRow();
		}

		public static int TableGetColumnCount()
		{
			return ImGuiNative.igTableGetColumnCount();
		}

		public static ImGuiTableColumnFlags TableGetColumnFlags()
		{
			int column_n = -1;
			return ImGuiNative.igTableGetColumnFlags(column_n);
		}

		public static ImGuiTableColumnFlags TableGetColumnFlags(int column_n)
		{
			return ImGuiNative.igTableGetColumnFlags(column_n);
		}

		public static int TableGetColumnIndex()
		{
			return ImGuiNative.igTableGetColumnIndex();
		}

		public unsafe static string TableGetColumnName()
		{
			int column_n = -1;
			byte* ptr = ImGuiNative.igTableGetColumnName_Int(column_n);
			return Util.StringFromPtr(ptr);
		}

		public unsafe static string TableGetColumnName(int column_n)
		{
			byte* ptr = ImGuiNative.igTableGetColumnName_Int(column_n);
			return Util.StringFromPtr(ptr);
		}

		public static int TableGetHoveredColumn()
		{
			return ImGuiNative.igTableGetHoveredColumn();
		}

		public static int TableGetRowIndex()
		{
			return ImGuiNative.igTableGetRowIndex();
		}

		public unsafe static ImGuiTableSortSpecsPtr TableGetSortSpecs()
		{
			ImGuiTableSortSpecs* nativePtr = ImGuiNative.igTableGetSortSpecs();
			return new ImGuiTableSortSpecsPtr(nativePtr);
		}

		public unsafe static void TableHeader(ReadOnlySpan<char> label)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			ImGuiNative.igTableHeader(ptr);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
		}

		public unsafe static void TableHeader(string label)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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()
		{
			byte b = ImGuiNative.igTableNextColumn();
			return b != 0;
		}

		public static void TableNextRow()
		{
			ImGuiTableRowFlags row_flags = ImGuiTableRowFlags.None;
			float min_row_height = 0f;
			ImGuiNative.igTableNextRow(row_flags, 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)
		{
			byte b = ImGuiNative.igTableSetColumnIndex(column_n);
			return b != 0;
		}

		public unsafe static void TableSetupColumn(ReadOnlySpan<char> label)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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(ReadOnlySpan<char> label, ImGuiTableColumnFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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(ReadOnlySpan<char> label, ImGuiTableColumnFlags flags, float init_width_or_weight)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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(ReadOnlySpan<char> label, ImGuiTableColumnFlags flags, float init_width_or_weight, uint user_id)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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(ReadOnlySpan<char> fmt)
		{
			int num = 0;
			byte* ptr;
			if (fmt != null)
			{
				num = Encoding.UTF8.GetByteCount(fmt);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 Text(string fmt)
		{
			int num = 0;
			byte* ptr;
			if (fmt != null)
			{
				num = Encoding.UTF8.GetByteCount(fmt);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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, ReadOnlySpan<char> fmt)
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (fmt != null)
			{
				num = Encoding.UTF8.GetByteCount(fmt);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 TextColored(Vector4 col, string fmt)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (fmt != null)
			{
				num = Encoding.UTF8.GetByteCount(fmt);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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(ReadOnlySpan<char> fmt)
		{
			int num = 0;
			byte* ptr;
			if (fmt != null)
			{
				num = Encoding.UTF8.GetByteCount(fmt);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 TextDisabled(string fmt)
		{
			int num = 0;
			byte* ptr;
			if (fmt != null)
			{
				num = Encoding.UTF8.GetByteCount(fmt);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 bool TextLink(ReadOnlySpan<char> label)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igTextLink(ptr);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool TextLink(string label)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igTextLink(ptr);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static void TextLinkOpenURL(ReadOnlySpan<char> label)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte* url = null;
			ImGuiNative.igTextLinkOpenURL(ptr, url);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
		}

		public unsafe static void TextLinkOpenURL(string label)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte* url = null;
			ImGuiNative.igTextLinkOpenURL(ptr, url);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
		}

		public unsafe static void TextLinkOpenURL(ReadOnlySpan<char> label, ReadOnlySpan<char> url)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (url != null)
			{
				num2 = Encoding.UTF8.GetByteCount(url);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(url, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiNative.igTextLinkOpenURL(ptr, ptr3);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr3);
			}
		}

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

		public unsafe static void TextUnformatted(ReadOnlySpan<char> text)
		{
			int num = 0;
			byte* ptr;
			if (text != null)
			{
				num = Encoding.UTF8.GetByteCount(text);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(text, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			ImGuiNative.igTextUnformatted(ptr, ptr + num);
			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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(text, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			ImGuiNative.igTextUnformatted(ptr, ptr + num);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
		}

		public unsafe static void TextWrapped(ReadOnlySpan<char> fmt)
		{
			int num = 0;
			byte* ptr;
			if (fmt != null)
			{
				num = Encoding.UTF8.GetByteCount(fmt);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 void TextWrapped(string fmt)
		{
			int num = 0;
			byte* ptr;
			if (fmt != null)
			{
				num = Encoding.UTF8.GetByteCount(fmt);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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(ReadOnlySpan<char> label)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igTreeNode_Str(ptr);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool TreeNode(string label)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igTreeNode_Str(ptr);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool TreeNode(ReadOnlySpan<char> str_id, ReadOnlySpan<char> fmt)
		{
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (fmt != null)
			{
				num2 = Encoding.UTF8.GetByteCount(fmt);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(fmt, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			byte b = ImGuiNative.igTreeNode_StrStr(ptr, ptr3);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr3);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (fmt != null)
			{
				num2 = Encoding.UTF8.GetByteCount(fmt);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(fmt, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			byte b = ImGuiNative.igTreeNode_StrStr(ptr, ptr3);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr3);
			}
			return b != 0;
		}

		public unsafe static bool TreeNode(IntPtr ptr_id, ReadOnlySpan<char> fmt)
		{
			void* ptr_id2 = ptr_id.ToPointer();
			int num = 0;
			byte* ptr;
			if (fmt != null)
			{
				num = Encoding.UTF8.GetByteCount(fmt);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(fmt, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igTreeNode_Ptr(ptr_id2, ptr);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(fmt, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igTreeNode_Ptr(ptr_id2, ptr);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool TreeNodeEx(ReadOnlySpan<char> label)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			ImGuiTreeNodeFlags flags = ImGuiTreeNodeFlags.None;
			byte b = ImGuiNative.igTreeNodeEx_Str(ptr, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

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

		public unsafe static bool TreeNodeEx(ReadOnlySpan<char> label, ImGuiTreeNodeFlags flags)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igTreeNodeEx_Str(ptr, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

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

		public unsafe static bool TreeNodeEx(ReadOnlySpan<char> str_id, ImGuiTreeNodeFlags flags, ReadOnlySpan<char> fmt)
		{
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (fmt != null)
			{
				num2 = Encoding.UTF8.GetByteCount(fmt);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(fmt, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			byte b = ImGuiNative.igTreeNodeEx_StrStr(ptr, flags, ptr3);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr3);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str_id, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (fmt != null)
			{
				num2 = Encoding.UTF8.GetByteCount(fmt);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(fmt, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			byte b = ImGuiNative.igTreeNodeEx_StrStr(ptr, flags, ptr3);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr3);
			}
			return b != 0;
		}

		public unsafe static bool TreeNodeEx(IntPtr ptr_id, ImGuiTreeNodeFlags flags, ReadOnlySpan<char> fmt)
		{
			void* ptr_id2 = ptr_id.ToPointer();
			int num = 0;
			byte* ptr;
			if (fmt != null)
			{
				num = Encoding.UTF8.GetByteCount(fmt);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(fmt, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igTreeNodeEx_Ptr(ptr_id2, flags, ptr);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(fmt, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.igTreeNodeEx_Ptr(ptr_id2, flags, ptr);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public static void TreePop()
		{
			ImGuiNative.igTreePop();
		}

		public unsafe static void TreePush(ReadOnlySpan<char> str_id)
		{
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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(string str_id)
		{
			int num = 0;
			byte* ptr;
			if (str_id != null)
			{
				num = Encoding.UTF8.GetByteCount(str_id);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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)
		{
			void* ptr_id2 = ptr_id.ToPointer();
			ImGuiNative.igTreePush_Ptr(ptr_id2);
		}

		public static void Unindent()
		{
			float indent_w = 0f;
			ImGuiNative.igUnindent(indent_w);
		}

		public static void Unindent(float indent_w)
		{
			ImGuiNative.igUnindent(indent_w);
		}

		public static void UpdatePlatformWindows()
		{
			ImGuiNative.igUpdatePlatformWindows();
		}

		public unsafe static void Value(ReadOnlySpan<char> prefix, bool b)
		{
			int num = 0;
			byte* ptr;
			if (prefix != null)
			{
				num = Encoding.UTF8.GetByteCount(prefix);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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, bool b)
		{
			int num = 0;
			byte* ptr;
			if (prefix != null)
			{
				num = Encoding.UTF8.GetByteCount(prefix);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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(ReadOnlySpan<char> prefix, int v)
		{
			int num = 0;
			byte* ptr;
			if (prefix != null)
			{
				num = Encoding.UTF8.GetByteCount(prefix);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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, int v)
		{
			int num = 0;
			byte* ptr;
			if (prefix != null)
			{
				num = Encoding.UTF8.GetByteCount(prefix);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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(ReadOnlySpan<char> prefix, uint v)
		{
			int num = 0;
			byte* ptr;
			if (prefix != null)
			{
				num = Encoding.UTF8.GetByteCount(prefix);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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, uint v)
		{
			int num = 0;
			byte* ptr;
			if (prefix != null)
			{
				num = Encoding.UTF8.GetByteCount(prefix);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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(ReadOnlySpan<char> prefix, float v)
		{
			int num = 0;
			byte* ptr;
			if (prefix != null)
			{
				num = Encoding.UTF8.GetByteCount(prefix);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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)
		{
			int num = 0;
			byte* ptr;
			if (prefix != null)
			{
				num = Encoding.UTF8.GetByteCount(prefix);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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(ReadOnlySpan<char> prefix, float v, ReadOnlySpan<char> float_format)
		{
			int num = 0;
			byte* ptr;
			if (prefix != null)
			{
				num = Encoding.UTF8.GetByteCount(prefix);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(prefix, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (float_format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(float_format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(float_format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiNative.igValue_Float(ptr, v, ptr3);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr3);
			}
		}

		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);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(prefix, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (float_format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(float_format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(float_format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiNative.igValue_Float(ptr, v, ptr3);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr3);
			}
		}

		public unsafe static bool VSliderFloat(ReadOnlySpan<char> label, Vector2 size, ref float v, float v_min, float v_max)
		{
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%.3f");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (float* v2 = &v)
			{
				byte b = ImGuiNative.igVSliderFloat(ptr, size, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool VSliderFloat(string label, Vector2 size, ref float v, float v_min, float v_max)
		{
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%.3f");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%.3f", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (float* v2 = &v)
			{
				byte b = ImGuiNative.igVSliderFloat(ptr, size, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool VSliderFloat(ReadOnlySpan<char> label, Vector2 size, ref float v, float v_min, float v_max, ReadOnlySpan<char> format)
		{
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (float* v2 = &v)
			{
				byte b = ImGuiNative.igVSliderFloat(ptr, size, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool VSliderFloat(string label, Vector2 size, ref float v, float v_min, float v_max, string format)
		{
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (float* v2 = &v)
			{
				byte b = ImGuiNative.igVSliderFloat(ptr, size, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool VSliderFloat(ReadOnlySpan<char> label, Vector2 size, ref float v, float v_min, float v_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
		{
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (float* v2 = &v)
			{
				byte b = ImGuiNative.igVSliderFloat(ptr, size, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool VSliderFloat(string label, Vector2 size, ref float v, float v_min, float v_max, string format, ImGuiSliderFlags flags)
		{
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (float* v2 = &v)
			{
				byte b = ImGuiNative.igVSliderFloat(ptr, size, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool VSliderInt(ReadOnlySpan<char> label, Vector2 size, ref int v, int v_min, int v_max)
		{
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%d");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igVSliderInt(ptr, size, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool VSliderInt(string label, Vector2 size, ref int v, int v_min, int v_max)
		{
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			num2 = Encoding.UTF8.GetByteCount("%d");
			byte* ptr3;
			if (num2 > 2048)
			{
				ptr3 = Util.Allocate(num2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
				ptr3 = ptr4;
			}
			int utf2 = Util.GetUtf8("%d", ptr3, num2);
			ptr3[utf2] = 0;
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igVSliderInt(ptr, size, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool VSliderInt(ReadOnlySpan<char> label, Vector2 size, ref int v, int v_min, int v_max, ReadOnlySpan<char> format)
		{
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igVSliderInt(ptr, size, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool VSliderInt(string label, Vector2 size, ref int v, int v_min, int v_max, string format)
		{
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igVSliderInt(ptr, size, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool VSliderInt(ReadOnlySpan<char> label, Vector2 size, ref int v, int v_min, int v_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
		{
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igVSliderInt(ptr, size, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool VSliderInt(string label, Vector2 size, ref int v, int v_min, int v_max, string format, ImGuiSliderFlags flags)
		{
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			int num2 = 0;
			byte* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			fixed (int* v2 = &v)
			{
				byte b = ImGuiNative.igVSliderInt(ptr, size, v2, v_min, v_max, ptr3, flags);
				if (num > 2048)
				{
					Util.Free(ptr);
				}
				if (num2 > 2048)
				{
					Util.Free(ptr3);
				}
				return b != 0;
			}
		}

		public unsafe static bool VSliderScalar(ReadOnlySpan<char> label, Vector2 size, ImGuiDataType data_type, IntPtr p_data, IntPtr p_min, IntPtr p_max)
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igVSliderScalar(ptr, size, data_type, p_data2, p_min2, p_max2, format, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool VSliderScalar(string label, Vector2 size, ImGuiDataType data_type, IntPtr p_data, IntPtr p_min, IntPtr p_max)
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 b = ImGuiNative.igVSliderScalar(ptr, size, data_type, p_data2, p_min2, p_max2, format, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe static bool VSliderScalar(ReadOnlySpan<char> label, Vector2 size, ImGuiDataType data_type, IntPtr p_data, IntPtr p_min, IntPtr p_max, ReadOnlySpan<char> format)
		{
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			byte b = ImGuiNative.igVSliderScalar(ptr, size, data_type, p_data2, p_min2, p_max2, ptr3, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr3);
			}
			return b != 0;
		}

		public unsafe static bool VSliderScalar(string label, Vector2 size, ImGuiDataType data_type, IntPtr p_data, IntPtr p_min, IntPtr p_max, string format)
		{
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			ImGuiSliderFlags flags = ImGuiSliderFlags.None;
			byte b = ImGuiNative.igVSliderScalar(ptr, size, data_type, p_data2, p_min2, p_max2, ptr3, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr3);
			}
			return b != 0;
		}

		public unsafe static bool VSliderScalar(ReadOnlySpan<char> label, Vector2 size, ImGuiDataType data_type, IntPtr p_data, IntPtr p_min, IntPtr p_max, ReadOnlySpan<char> format, ImGuiSliderFlags flags)
		{
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			byte b = ImGuiNative.igVSliderScalar(ptr, size, data_type, p_data2, p_min2, p_max2, ptr3, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr3);
			}
			return b != 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)
		{
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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* ptr3;
			if (format != null)
			{
				num2 = Encoding.UTF8.GetByteCount(format);
				if (num2 > 2048)
				{
					ptr3 = Util.Allocate(num2 + 1);
				}
				else
				{
					byte* ptr4 = stackalloc byte[(int)(uint)(num2 + 1)];
					ptr3 = ptr4;
				}
				int utf2 = Util.GetUtf8(format, ptr3, num2);
				ptr3[utf2] = 0;
			}
			else
			{
				ptr3 = null;
			}
			byte b = ImGuiNative.igVSliderScalar(ptr, size, data_type, p_data2, p_min2, p_max2, ptr3, flags);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			if (num2 > 2048)
			{
				Util.Free(ptr3);
			}
			return b != 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;
			if (byteCount > 2048)
			{
				ptr = Util.Allocate(byteCount + 1);
			}
			else
			{
				byte* ptr2 = stackalloc byte[(int)(uint)(byteCount + 1)];
				ptr = ptr2;
			}
			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;
			if (byteCount > 2048)
			{
				ptr = Util.Allocate(byteCount + 1);
			}
			else
			{
				byte* ptr2 = stackalloc byte[(int)(uint)(byteCount + 1)];
				ptr = ptr2;
			}
			Util.GetUtf8(label, ptr, byteCount);
			int byteCount2 = Encoding.UTF8.GetByteCount(input);
			int num = Math.Max((int)(maxLength + 1), byteCount2 + 1);
			byte* ptr3;
			byte* ptr4;
			if (num > 2048)
			{
				ptr3 = Util.Allocate(num);
				ptr4 = Util.Allocate(num);
			}
			else
			{
				byte* ptr5 = stackalloc byte[(int)(uint)num];
				ptr3 = ptr5;
				byte* ptr6 = stackalloc byte[(int)(uint)num];
				ptr4 = ptr6;
			}
			Util.GetUtf8(input, ptr3, num);
			uint byteCount3 = (uint)(num - byteCount2);
			Unsafe.InitBlockUnaligned(ptr3 + byteCount2, 0, byteCount3);
			Unsafe.CopyBlock(ptr4, ptr3, (uint)num);
			byte b = ImGuiNative.igInputText(ptr, 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 (num > 2048)
			{
				Util.Free(ptr3);
				Util.Free(ptr4);
			}
			return b != 0;
		}

		public static bool InputTextMultiline(string label, ref string input, uint maxLength, Vector2 size)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			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)
		{
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			int byteCount = Encoding.UTF8.GetByteCount(label);
			byte* ptr;
			if (byteCount > 2048)
			{
				ptr = Util.Allocate(byteCount + 1);
			}
			else
			{
				byte* ptr2 = stackalloc byte[(int)(uint)(byteCount + 1)];
				ptr = ptr2;
			}
			Util.GetUtf8(label, ptr, byteCount);
			int byteCount2 = Encoding.UTF8.GetByteCount(input);
			int num = Math.Max((int)(maxLength + 1), byteCount2 + 1);
			byte* ptr3;
			byte* ptr4;
			if (num > 2048)
			{
				ptr3 = Util.Allocate(num);
				ptr4 = Util.Allocate(num);
			}
			else
			{
				byte* ptr5 = stackalloc byte[(int)(uint)num];
				ptr3 = ptr5;
				byte* ptr6 = stackalloc byte[(int)(uint)num];
				ptr4 = ptr6;
			}
			Util.GetUtf8(input, ptr3, num);
			uint byteCount3 = (uint)(num - byteCount2);
			Unsafe.InitBlockUnaligned(ptr3 + byteCount2, 0, byteCount3);
			Unsafe.CopyBlock(ptr4, ptr3, (uint)num);
			byte b = ImGuiNative.igInputTextMultiline(ptr, ptr3, (uint)num, size, flags, callback, user_data.ToPointer());
			if (!Util.AreStringsEqual(ptr4, num, ptr3))
			{
				input = Util.StringFromPtr(ptr3);
			}
			if (byteCount > 2048)
			{
				Util.Free(ptr);
			}
			if (num > 2048)
			{
				Util.Free(ptr3);
				Util.Free(ptr4);
			}
			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;
			if (byteCount > 2048)
			{
				ptr = Util.Allocate(byteCount + 1);
			}
			else
			{
				byte* ptr2 = stackalloc byte[(int)(uint)(byteCount + 1)];
				ptr = ptr2;
			}
			Util.GetUtf8(label, ptr, byteCount);
			int byteCount2 = Encoding.UTF8.GetByteCount(hint);
			byte* ptr3;
			if (byteCount2 > 2048)
			{
				ptr3 = Util.Allocate(byteCount2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(byteCount2 + 1)];
				ptr3 = ptr4;
			}
			Util.GetUtf8(hint, ptr3, byteCount2);
			int byteCount3 = Encoding.UTF8.GetByteCount(input);
			int num = Math.Max((int)(maxLength + 1), byteCount3 + 1);
			byte* ptr5;
			byte* ptr6;
			if (num > 2048)
			{
				ptr5 = Util.Allocate(num);
				ptr6 = Util.Allocate(num);
			}
			else
			{
				byte* ptr7 = stackalloc byte[(int)(uint)num];
				ptr5 = ptr7;
				byte* ptr8 = stackalloc byte[(int)(uint)num];
				ptr6 = ptr8;
			}
			Util.GetUtf8(input, ptr5, num);
			uint byteCount4 = (uint)(num - byteCount3);
			Unsafe.InitBlockUnaligned(ptr5 + byteCount3, 0, byteCount4);
			Unsafe.CopyBlock(ptr6, ptr5, (uint)num);
			byte b = ImGuiNative.igInputTextWithHint(ptr, ptr3, ptr5, (uint)num, flags, callback, user_data.ToPointer());
			if (!Util.AreStringsEqual(ptr6, num, ptr5))
			{
				input = Util.StringFromPtr(ptr5);
			}
			if (byteCount > 2048)
			{
				Util.Free(ptr);
			}
			if (byteCount2 > 2048)
			{
				Util.Free(ptr3);
			}
			if (num > 2048)
			{
				Util.Free(ptr5);
				Util.Free(ptr6);
			}
			return b != 0;
		}

		public static Vector2 CalcTextSize(string text, int start)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			return CalcTextSizeImpl(text, start);
		}

		public static Vector2 CalcTextSize(string text, float wrapWidth)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			return CalcTextSizeImpl(text, 0, null, hideTextAfterDoubleHash: false, wrapWidth);
		}

		public static Vector2 CalcTextSize(string text, int start, int length)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			return CalcTextSizeImpl(text, start, length);
		}

		public static Vector2 CalcTextSize(string text, int start, bool hideTextAfterDoubleHash)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			bool hideTextAfterDoubleHash2 = hideTextAfterDoubleHash;
			return CalcTextSizeImpl(text, start, null, hideTextAfterDoubleHash2);
		}

		public static Vector2 CalcTextSize(string text, int start, float wrapWidth)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			return CalcTextSizeImpl(text, start, null, hideTextAfterDoubleHash: false, wrapWidth);
		}

		public static Vector2 CalcTextSize(string text, int start, int length, bool hideTextAfterDoubleHash)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			return CalcTextSizeImpl(text, start, length, hideTextAfterDoubleHash);
		}

		public static Vector2 CalcTextSize(string text, int start, int length, float wrapWidth)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return CalcTextSizeImpl(text, start, length, hideTextAfterDoubleHash: false, wrapWidth);
		}

		public static Vector2 CalcTextSize(string text, int start, int length, bool hideTextAfterDoubleHash, float wrapWidth)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return CalcTextSizeImpl(text, start, length, hideTextAfterDoubleHash, wrapWidth);
		}

		private static Vector2 CalcTextSizeImpl(string text, int start = 0, int? length = null, bool hideTextAfterDoubleHash = false, float wrapWidth = -1f)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			return CalcTextSize(text.Substring(start, length ?? (text.Length - start)), hideTextAfterDoubleHash, wrapWidth);
		}

		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;
			if (byteCount > 2048)
			{
				ptr = Util.Allocate(byteCount + 1);
			}
			else
			{
				byte* ptr2 = stackalloc byte[(int)(uint)(byteCount + 1)];
				ptr = ptr2;
			}
			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;
			if (byteCount > 2048)
			{
				ptr = Util.Allocate(byteCount + 1);
			}
			else
			{
				byte* ptr2 = stackalloc byte[(int)(uint)(byteCount + 1)];
				ptr = ptr2;
			}
			Util.GetUtf8(name, ptr, byteCount);
			byte* p_open = null;
			byte b = ImGuiNative.igBegin(ptr, p_open, flags);
			if (byteCount > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public static bool MenuItem(string label, bool enabled)
		{
			return MenuItem(label, string.Empty, selected: false, enabled);
		}

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

		public static bool InputText(ReadOnlySpan<char> label, byte[] buf, uint buf_size)
		{
			return InputText(label, buf, buf_size, ImGuiInputTextFlags.None, null, IntPtr.Zero);
		}

		public static bool InputText(ReadOnlySpan<char> label, byte[] buf, uint buf_size, ImGuiInputTextFlags flags)
		{
			return InputText(label, buf, buf_size, flags, null, IntPtr.Zero);
		}

		public static bool InputText(ReadOnlySpan<char> 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(ReadOnlySpan<char> label, byte[] buf, uint buf_size, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, IntPtr user_data)
		{
			int byteCount = Encoding.UTF8.GetByteCount(label);
			byte* ptr;
			if (byteCount > 2048)
			{
				ptr = Util.Allocate(byteCount + 1);
			}
			else
			{
				byte* ptr2 = stackalloc byte[(int)(uint)(byteCount + 1)];
				ptr = ptr2;
			}
			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(ReadOnlySpan<char> label, ref string input, uint maxLength)
		{
			return InputText(label, ref input, maxLength, ImGuiInputTextFlags.None, null, IntPtr.Zero);
		}

		public static bool InputText(ReadOnlySpan<char> label, ref string input, uint maxLength, ImGuiInputTextFlags flags)
		{
			return InputText(label, ref input, maxLength, flags, null, IntPtr.Zero);
		}

		public static bool InputText(ReadOnlySpan<char> 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(ReadOnlySpan<char> label, ref string input, uint maxLength, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, IntPtr user_data)
		{
			int byteCount = Encoding.UTF8.GetByteCount(label);
			byte* ptr;
			if (byteCount > 2048)
			{
				ptr = Util.Allocate(byteCount + 1);
			}
			else
			{
				byte* ptr2 = stackalloc byte[(int)(uint)(byteCount + 1)];
				ptr = ptr2;
			}
			Util.GetUtf8(label, ptr, byteCount);
			int byteCount2 = Encoding.UTF8.GetByteCount(input);
			int num = Math.Max((int)(maxLength + 1), byteCount2 + 1);
			byte* ptr3;
			byte* ptr4;
			if (num > 2048)
			{
				ptr3 = Util.Allocate(num);
				ptr4 = Util.Allocate(num);
			}
			else
			{
				byte* ptr5 = stackalloc byte[(int)(uint)num];
				ptr3 = ptr5;
				byte* ptr6 = stackalloc byte[(int)(uint)num];
				ptr4 = ptr6;
			}
			Util.GetUtf8(input, ptr3, num);
			uint byteCount3 = (uint)(num - byteCount2);
			Unsafe.InitBlockUnaligned(ptr3 + byteCount2, 0, byteCount3);
			Unsafe.CopyBlock(ptr4, ptr3, (uint)num);
			byte b = ImGuiNative.igInputText(ptr, 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 (num > 2048)
			{
				Util.Free(ptr3);
				Util.Free(ptr4);
			}
			return b != 0;
		}

		public static bool InputTextMultiline(ReadOnlySpan<char> label, ref string input, uint maxLength, Vector2 size)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return InputTextMultiline(label, ref input, maxLength, size, ImGuiInputTextFlags.None, null, IntPtr.Zero);
		}

		public static bool InputTextMultiline(ReadOnlySpan<char> label, ref string input, uint maxLength, Vector2 size, ImGuiInputTextFlags flags)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return InputTextMultiline(label, ref input, maxLength, size, flags, null, IntPtr.Zero);
		}

		public static bool InputTextMultiline(ReadOnlySpan<char> label, ref string input, uint maxLength, Vector2 size, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return InputTextMultiline(label, ref input, maxLength, size, flags, callback, IntPtr.Zero);
		}

		public unsafe static bool InputTextMultiline(ReadOnlySpan<char> label, ref string input, uint maxLength, Vector2 size, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, IntPtr user_data)
		{
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			int byteCount = Encoding.UTF8.GetByteCount(label);
			byte* ptr;
			if (byteCount > 2048)
			{
				ptr = Util.Allocate(byteCount + 1);
			}
			else
			{
				byte* ptr2 = stackalloc byte[(int)(uint)(byteCount + 1)];
				ptr = ptr2;
			}
			Util.GetUtf8(label, ptr, byteCount);
			int byteCount2 = Encoding.UTF8.GetByteCount(input);
			int num = Math.Max((int)(maxLength + 1), byteCount2 + 1);
			byte* ptr3;
			byte* ptr4;
			if (num > 2048)
			{
				ptr3 = Util.Allocate(num);
				ptr4 = Util.Allocate(num);
			}
			else
			{
				byte* ptr5 = stackalloc byte[(int)(uint)num];
				ptr3 = ptr5;
				byte* ptr6 = stackalloc byte[(int)(uint)num];
				ptr4 = ptr6;
			}
			Util.GetUtf8(input, ptr3, num);
			uint byteCount3 = (uint)(num - byteCount2);
			Unsafe.InitBlockUnaligned(ptr3 + byteCount2, 0, byteCount3);
			Unsafe.CopyBlock(ptr4, ptr3, (uint)num);
			byte b = ImGuiNative.igInputTextMultiline(ptr, ptr3, (uint)num, size, flags, callback, user_data.ToPointer());
			if (!Util.AreStringsEqual(ptr4, num, ptr3))
			{
				input = Util.StringFromPtr(ptr3);
			}
			if (byteCount > 2048)
			{
				Util.Free(ptr);
			}
			if (num > 2048)
			{
				Util.Free(ptr3);
				Util.Free(ptr4);
			}
			return b != 0;
		}

		public static bool InputTextWithHint(ReadOnlySpan<char> label, ReadOnlySpan<char> hint, ref string input, uint maxLength)
		{
			return InputTextWithHint(label, hint, ref input, maxLength, ImGuiInputTextFlags.None, null, IntPtr.Zero);
		}

		public static bool InputTextWithHint(ReadOnlySpan<char> label, ReadOnlySpan<char> hint, ref string input, uint maxLength, ImGuiInputTextFlags flags)
		{
			return InputTextWithHint(label, hint, ref input, maxLength, flags, null, IntPtr.Zero);
		}

		public static bool InputTextWithHint(ReadOnlySpan<char> label, ReadOnlySpan<char> 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(ReadOnlySpan<char> label, ReadOnlySpan<char> hint, ref string input, uint maxLength, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, IntPtr user_data)
		{
			int byteCount = Encoding.UTF8.GetByteCount(label);
			byte* ptr;
			if (byteCount > 2048)
			{
				ptr = Util.Allocate(byteCount + 1);
			}
			else
			{
				byte* ptr2 = stackalloc byte[(int)(uint)(byteCount + 1)];
				ptr = ptr2;
			}
			Util.GetUtf8(label, ptr, byteCount);
			int byteCount2 = Encoding.UTF8.GetByteCount(hint);
			byte* ptr3;
			if (byteCount2 > 2048)
			{
				ptr3 = Util.Allocate(byteCount2 + 1);
			}
			else
			{
				byte* ptr4 = stackalloc byte[(int)(uint)(byteCount2 + 1)];
				ptr3 = ptr4;
			}
			Util.GetUtf8(hint, ptr3, byteCount2);
			int byteCount3 = Encoding.UTF8.GetByteCount(input);
			int num = Math.Max((int)(maxLength + 1), byteCount3 + 1);
			byte* ptr5;
			byte* ptr6;
			if (num > 2048)
			{
				ptr5 = Util.Allocate(num);
				ptr6 = Util.Allocate(num);
			}
			else
			{
				byte* ptr7 = stackalloc byte[(int)(uint)num];
				ptr5 = ptr7;
				byte* ptr8 = stackalloc byte[(int)(uint)num];
				ptr6 = ptr8;
			}
			Util.GetUtf8(input, ptr5, num);
			uint byteCount4 = (uint)(num - byteCount3);
			Unsafe.InitBlockUnaligned(ptr5 + byteCount3, 0, byteCount4);
			Unsafe.CopyBlock(ptr6, ptr5, (uint)num);
			byte b = ImGuiNative.igInputTextWithHint(ptr, ptr3, ptr5, (uint)num, flags, callback, user_data.ToPointer());
			if (!Util.AreStringsEqual(ptr6, num, ptr5))
			{
				input = Util.StringFromPtr(ptr5);
			}
			if (byteCount > 2048)
			{
				Util.Free(ptr);
			}
			if (byteCount2 > 2048)
			{
				Util.Free(ptr3);
			}
			if (num > 2048)
			{
				Util.Free(ptr5);
				Util.Free(ptr6);
			}
			return b != 0;
		}

		public static Vector2 CalcTextSize(ReadOnlySpan<char> text, int start)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			return CalcTextSizeImpl(text, start);
		}

		public static Vector2 CalcTextSize(ReadOnlySpan<char> text, float wrapWidth)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			return CalcTextSizeImpl(text, 0, null, hideTextAfterDoubleHash: false, wrapWidth);
		}

		public static Vector2 CalcTextSize(ReadOnlySpan<char> text, int start, int length)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			return CalcTextSizeImpl(text, start, length);
		}

		public static Vector2 CalcTextSize(ReadOnlySpan<char> text, int start, bool hideTextAfterDoubleHash)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			bool hideTextAfterDoubleHash2 = hideTextAfterDoubleHash;
			return CalcTextSizeImpl(text, start, null, hideTextAfterDoubleHash2);
		}

		public static Vector2 CalcTextSize(ReadOnlySpan<char> text, int start, float wrapWidth)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			return CalcTextSizeImpl(text, start, null, hideTextAfterDoubleHash: false, wrapWidth);
		}

		public static Vector2 CalcTextSize(ReadOnlySpan<char> text, int start, int length, bool hideTextAfterDoubleHash)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			return CalcTextSizeImpl(text, start, length, hideTextAfterDoubleHash);
		}

		public static Vector2 CalcTextSize(ReadOnlySpan<char> text, int start, int length, float wrapWidth)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return CalcTextSizeImpl(text, start, length, hideTextAfterDoubleHash: false, wrapWidth);
		}

		public static Vector2 CalcTextSize(ReadOnlySpan<char> text, int start, int length, bool hideTextAfterDoubleHash, float wrapWidth)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return CalcTextSizeImpl(text, start, length, hideTextAfterDoubleHash, wrapWidth);
		}

		private static Vector2 CalcTextSizeImpl(ReadOnlySpan<char> text, int start = 0, int? length = null, bool hideTextAfterDoubleHash = false, float wrapWidth = -1f)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			return CalcTextSize(text.Slice(start, length ?? (text.Length - start)), hideTextAfterDoubleHash, wrapWidth);
		}

		public static bool InputText(ReadOnlySpan<char> label, IntPtr buf, uint buf_size)
		{
			return InputText(label, buf, buf_size, ImGuiInputTextFlags.None, null, IntPtr.Zero);
		}

		public static bool InputText(ReadOnlySpan<char> label, IntPtr buf, uint buf_size, ImGuiInputTextFlags flags)
		{
			return InputText(label, buf, buf_size, flags, null, IntPtr.Zero);
		}

		public static bool InputText(ReadOnlySpan<char> 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(ReadOnlySpan<char> label, IntPtr buf, uint buf_size, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, IntPtr user_data)
		{
			int byteCount = Encoding.UTF8.GetByteCount(label);
			byte* ptr;
			if (byteCount > 2048)
			{
				ptr = Util.Allocate(byteCount + 1);
			}
			else
			{
				byte* ptr2 = stackalloc byte[(int)(uint)(byteCount + 1)];
				ptr = ptr2;
			}
			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(ReadOnlySpan<char> name, ImGuiWindowFlags flags)
		{
			int byteCount = Encoding.UTF8.GetByteCount(name);
			byte* ptr;
			if (byteCount > 2048)
			{
				ptr = Util.Allocate(byteCount + 1);
			}
			else
			{
				byte* ptr2 = stackalloc byte[(int)(uint)(byteCount + 1)];
				ptr = ptr2;
			}
			Util.GetUtf8(name, ptr, byteCount);
			byte* p_open = null;
			byte b = ImGuiNative.igBegin(ptr, p_open, flags);
			if (byteCount > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public static bool MenuItem(ReadOnlySpan<char> label, bool enabled)
		{
			return MenuItem(label, string.Empty, selected: false, enabled);
		}

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

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static IntPtr ImageId(Texture texture)
		{
			return ImGuiController.CurrentController.Textures.GetOrCreate(texture);
		}

		public static void Image(Texture texture)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			IntPtr user_texture_id = ImageId(texture);
			Vector2 image_size = default(Vector2);
			((Vector2)(ref image_size))..ctor((float)texture.width, (float)texture.height);
			Vector2 uv = default(Vector2);
			Vector2 uv2 = default(Vector2);
			((Vector2)(ref uv2))..ctor(1f, 1f);
			Vector4 tint_col = default(Vector4);
			((Vector4)(ref tint_col))..ctor(1f, 1f, 1f, 1f);
			ImGuiNative.igImage(user_texture_id, image_size, uv, uv2, tint_col, default(Vector4));
		}

		public static void Image(Texture texture, Vector2 size)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			IntPtr user_texture_id = ImageId(texture);
			Vector2 uv = default(Vector2);
			Vector2 uv2 = default(Vector2);
			((Vector2)(ref uv2))..ctor(1f, 1f);
			Vector4 tint_col = default(Vector4);
			((Vector4)(ref tint_col))..ctor(1f, 1f, 1f, 1f);
			ImGuiNative.igImage(user_texture_id, size, uv, uv2, tint_col, default(Vector4));
		}

		public static void Image(Sprite sprite)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			Texture2D texture = sprite.texture;
			IntPtr user_texture_id = ImageId((Texture)(object)texture);
			Rect rect = sprite.rect;
			Vector2 size = ((Rect)(ref rect)).size;
			Vector2[] uv = sprite.uv;
			Vector2 uv2 = default(Vector2);
			((Vector2)(ref uv2))..ctor(uv[0].x, 1f - uv[0].y);
			Vector2 uv3 = default(Vector2);
			((Vector2)(ref uv3))..ctor(uv[1].x, 1f - uv[1].y);
			Vector4 tint_col = default(Vector4);
			((Vector4)(ref tint_col))..ctor(1f, 1f, 1f, 1f);
			ImGuiNative.igImage(user_texture_id, size, uv2, uv3, tint_col, default(Vector4));
		}

		public static void Image(Sprite sprite, Vector2 size)
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			Texture2D texture = sprite.texture;
			IntPtr user_texture_id = ImageId((Texture)(object)texture);
			Vector2[] uv = sprite.uv;
			Vector2 uv2 = default(Vector2);
			((Vector2)(ref uv2))..ctor(uv[0].x, 1f - uv[0].y);
			Vector2 uv3 = default(Vector2);
			((Vector2)(ref uv3))..ctor(uv[1].x, 1f - uv[1].y);
			Vector4 tint_col = default(Vector4);
			((Vector4)(ref tint_col))..ctor(1f, 1f, 1f, 1f);
			ImGuiNative.igImage(user_texture_id, size, uv2, uv3, tint_col, default(Vector4));
		}

		public static bool ImageButton(string str_id, Texture texture)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			IntPtr user_texture_id = ImageId(texture);
			Vector2 image_size = default(Vector2);
			((Vector2)(ref image_size))..ctor((float)texture.width, (float)texture.height);
			return ImageButton(str_id, user_texture_id, image_size);
		}

		public static bool ImageButton(string str_id, Texture texture, Vector2 size)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			IntPtr user_texture_id = ImageId(texture);
			return ImageButton(str_id, user_texture_id, size);
		}

		public static bool ImageButton(string str_id, Sprite sprite)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			Texture2D texture = sprite.texture;
			IntPtr user_texture_id = ImageId((Texture)(object)texture);
			Rect rect = sprite.rect;
			Vector2 size = ((Rect)(ref rect)).size;
			Vector2[] uv = sprite.uv;
			Vector2 uv2 = default(Vector2);
			((Vector2)(ref uv2))..ctor(uv[0].x, 1f - uv[0].y);
			Vector2 uv3 = default(Vector2);
			((Vector2)(ref uv3))..ctor(uv[1].x, 1f - uv[1].y);
			return ImageButton(str_id, user_texture_id, size, uv2, uv3);
		}

		public static bool ImageButton(string str_id, Sprite sprite, Vector2 size)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			Texture2D texture = sprite.texture;
			IntPtr user_texture_id = ImageId((Texture)(object)texture);
			Vector2[] uv = sprite.uv;
			Vector2 uv2 = default(Vector2);
			((Vector2)(ref uv2))..ctor(uv[0].x, 1f - uv[0].y);
			Vector2 uv3 = default(Vector2);
			((Vector2)(ref uv3))..ctor(uv[1].x, 1f - uv[1].y);
			return ImageButton(str_id, user_texture_id, size, uv2, uv3);
		}
	}
	[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
	}
	[Flags]
	public enum ImGuiChildFlags
	{
		None = 0,
		Border = 1,
		AlwaysUseWindowPadding = 2,
		ResizeX = 4,
		ResizeY = 8,
		AutoResizeX = 0x10,
		AutoResizeY = 0x20,
		AlwaysAutoResize = 0x40,
		FrameStyle = 0x80,
		NavFlattened = 0x100
	}
	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,
		TabHovered,
		Tab,
		TabSelected,
		TabSelectedOverline,
		TabDimmed,
		TabDimmedSelected,
		TabDimmedSelectedOverline,
		DockingPreview,
		DockingEmptyBg,
		PlotLines,
		PlotLinesHovered,
		PlotHistogram,
		PlotHistogramHovered,
		TableHeaderBg,
		TableBorderStrong,
		TableBorderLight,
		TableRowBg,
		TableRowBgAlt,
		TextLink,
		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,
		WidthFitPreview = 0x80,
		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,
		NoKeyboard = 0x40,
		DockingEnable = 0x80,
		ViewportsEnable = 0x400,
		DpiEnableScaleViewports = 0x4000,
		DpiEnableScaleFonts = 0x8000,
		IsSRGB = 0x100000,
		IsTouchScreen = 0x200000
	}
	public enum ImGuiDataType
	{
		S8,
		U8,
		S16,
		U16,
		S32,
		U32,
		S64,
		U64,
		Float,
		Double,
		Bool,
		COUNT
	}
	public enum ImGuiDir
	{
		None = -1,
		Left,
		Right,
		Up,
		Down,
		COUNT
	}
	[Flags]
	public enum ImGuiDockNodeFlags
	{
		None = 0,
		KeepAliveOnly = 1,
		NoDockingOverCentralNode = 4,
		PassthruCentralNode = 8,
		NoDockingSplit = 0x10,
		NoResize = 0x20,
		AutoHideTabBar = 0x40,
		NoUndocking = 0x80
	}
	[Flags]
	public enum ImGuiDragDropFlags
	{
		None = 0,
		SourceNoPreviewTooltip = 1,
		SourceNoDisableHover = 2,
		SourceNoHoldToOpenOthers = 4,
		SourceAllowNullID = 8,
		SourceExtern = 0x10,
		PayloadAutoExpire = 0x20,
		PayloadNoCrossContext = 0x40,
		PayloadNoCrossProcess = 0x80,
		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,
		AllowWhenOverlappedByItem = 0x100,
		AllowWhenOverlappedByWindow = 0x200,
		AllowWhenDisabled = 0x400,
		NoNavOverride = 0x800,
		AllowWhenOverlapped = 0x300,
		RectOnly = 0x3A0,
		RootAndChildWindows = 3,
		ForTooltip = 0x1000,
		Stationary = 0x2000,
		DelayNone = 0x4000,
		DelayShort = 0x8000,
		DelayNormal = 0x10000,
		NoSharedDelay = 0x20000
	}
	[Flags]
	public enum ImGuiInputFlags
	{
		None = 0,
		Repeat = 1,
		RouteActive = 0x400,
		RouteFocused = 0x800,
		RouteGlobal = 0x1000,
		RouteAlways = 0x2000,
		RouteOverFocused = 0x4000,
		RouteOverActive = 0x8000,
		RouteUnlessBgFocused = 0x10000,
		RouteFromRootWindow = 0x20000,
		Tooltip = 0x40000
	}
	public struct ImGuiInputTextCallbackData
	{
		public IntPtr Ctx;

		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 IntPtr Ctx => ref Unsafe.AsRef<IntPtr>(&NativePtr->Ctx);

		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()
		{
			byte b = ImGuiNative.ImGuiInputTextCallbackData_HasSelection(NativePtr);
			return b != 0;
		}

		public unsafe void InsertChars(int pos, ReadOnlySpan<char> text)
		{
			int num = 0;
			byte* ptr;
			if (text != null)
			{
				num = Encoding.UTF8.GetByteCount(text);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(text, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			ImGuiNative.ImGuiInputTextCallbackData_InsertChars(NativePtr, pos, ptr, ptr + num);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
		}

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

		public unsafe void SelectAll()
		{
			ImGuiNative.ImGuiInputTextCallbackData_SelectAll(NativePtr);
		}
	}
	[Flags]
	public enum ImGuiInputTextFlags
	{
		None = 0,
		CharsDecimal = 1,
		CharsHexadecimal = 2,
		CharsScientific = 4,
		CharsUppercase = 8,
		CharsNoBlank = 0x10,
		AllowTabInput = 0x20,
		EnterReturnsTrue = 0x40,
		EscapeClearsAll = 0x80,
		CtrlEnterForNewLine = 0x100,
		ReadOnly = 0x200,
		Password = 0x400,
		AlwaysOverwrite = 0x800,
		AutoSelectAll = 0x1000,
		ParseEmptyRefVal = 0x2000,
		DisplayEmptyRefVal = 0x4000,
		NoHorizontalScroll = 0x8000,
		NoUndoRedo = 0x10000,
		CallbackCompletion = 0x20000,
		CallbackHistory = 0x40000,
		CallbackAlways = 0x80000,
		CallbackCharFilter = 0x100000,
		CallbackResize = 0x200000,
		CallbackEdit = 0x400000
	}
	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 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 ConfigNavSwapGamepadButtons;

		public byte ConfigInputTrickleEventQueue;

		public byte ConfigInputTextCursorBlink;

		public byte ConfigInputTextEnterKeepActive;

		public byte ConfigDragClickToInputText;

		public byte ConfigWindowsResizeFromEdges;

		public byte ConfigWindowsMoveFromTitleBarOnly;

		public float ConfigMemoryCompactTimer;

		public float MouseDoubleClickTime;

		public float MouseDoubleClickMaxDist;

		public float MouseDragThreshold;

		public float KeyRepeatDelay;

		public float KeyRepeatRate;

		public byte ConfigDebugIsDebuggerPresent;

		public byte ConfigDebugBeginReturnValueOnce;

		public byte ConfigDebugBeginReturnValueLoop;

		public byte ConfigDebugIgnoreFocusLoss;

		public byte ConfigDebugIniSettings;

		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 PlatformOpenInShellFn;

		public unsafe void* PlatformOpenInShellUserData;

		public IntPtr PlatformSetImeDataFn;

		public ushort PlatformLocaleDecimalPoint;

		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 Vector2 MouseDelta;

		public IntPtr Ctx;

		public Vector2 MousePos;

		public unsafe fixed byte MouseDown[5];

		public float MouseWheel;

		public float MouseWheelH;

		public ImGuiMouseSource MouseSource;

		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 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 byte MouseWheelRequestAxisSwap;

		public byte MouseCtrlLeftAsRightClick;

		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
	{
		private static readonly HashSet<IntPtr> _managedAllocations = new HashSet<IntPtr>(IntPtrEqualityComparer.Instance);

		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>((void*)(&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 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>((void*)(&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 ConfigNavSwapGamepadButtons => ref Unsafe.AsRef<bool>(&NativePtr->ConfigNavSwapGamepadButtons);

		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 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 bool ConfigDebugIsDebuggerPresent => ref Unsafe.AsRef<bool>(&NativePtr->ConfigDebugIsDebuggerPresent);

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

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

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

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

		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 PlatformOpenInShellFn => ref Unsafe.AsRef<IntPtr>(&NativePtr->PlatformOpenInShellFn);

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

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

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

		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 Vector2 MouseDelta => ref Unsafe.AsRef<Vector2>((void*)(&NativePtr->MouseDelta));

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

		public unsafe ref Vector2 MousePos => ref Unsafe.AsRef<Vector2>((void*)(&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 ImGuiMouseSource MouseSource => ref Unsafe.AsRef<ImGuiMouseSource>(&NativePtr->MouseSource);

		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, 154);

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

		public unsafe ref Vector2 MousePosPrev => ref Unsafe.AsRef<Vector2>((void*)(&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 ref bool MouseWheelRequestAxisSwap => ref Unsafe.AsRef<bool>(&NativePtr->MouseWheelRequestAxisSwap);

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

		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(ReadOnlySpan<char> str)
		{
			int num = 0;
			byte* ptr;
			if (str != null)
			{
				num = Encoding.UTF8.GetByteCount(str);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 AddInputCharactersUTF8(string str)
		{
			int num = 0;
			byte* ptr;
			if (str != null)
			{
				num = Encoding.UTF8.GetByteCount(str);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 AddMouseSourceEvent(ImGuiMouseSource source)
		{
			ImGuiNative.ImGuiIO_AddMouseSourceEvent(NativePtr, source);
		}

		public unsafe void AddMouseViewportEvent(uint id)
		{
			ImGuiNative.ImGuiIO_AddMouseViewportEvent(NativePtr, id);
		}

		public unsafe void AddMouseWheelEvent(float wheel_x, float wheel_y)
		{
			ImGuiNative.ImGuiIO_AddMouseWheelEvent(NativePtr, wheel_x, wheel_y);
		}

		public unsafe void ClearEventsQueue()
		{
			ImGuiNative.ImGuiIO_ClearEventsQueue(NativePtr);
		}

		public unsafe void ClearInputKeys()
		{
			ImGuiNative.ImGuiIO_ClearInputKeys(NativePtr);
		}

		public unsafe void ClearInputMouse()
		{
			ImGuiNative.ImGuiIO_ClearInputMouse(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 unsafe void SetBackendRendererName(string name)
		{
			if (NativePtr->BackendRendererName != null)
			{
				if (_managedAllocations.Contains((IntPtr)NativePtr->BackendRendererName))
				{
					Util.Free(NativePtr->BackendRendererName);
				}
				NativePtr->BackendRendererName = null;
			}
			if (name != null)
			{
				int byteCount = Encoding.UTF8.GetByteCount(name);
				byte* ptr = Util.Allocate(byteCount + 1);
				int utf = Util.GetUtf8(name, ptr, byteCount);
				ptr[utf] = 0;
				NativePtr->BackendRendererName = ptr;
				_managedAllocations.Add((IntPtr)ptr);
			}
		}

		public unsafe void SetBackendPlatformName(string name)
		{
			if (NativePtr->BackendPlatformName != null)
			{
				if (_managedAllocations.Contains((IntPtr)NativePtr->BackendPlatformName))
				{
					Util.Free(NativePtr->BackendPlatformName);
				}
				NativePtr->BackendPlatformName = null;
			}
			if (name != null)
			{
				int byteCount = Encoding.UTF8.GetByteCount(name);
				byte* ptr = Util.Allocate(byteCount + 1);
				int utf = Util.GetUtf8(name, ptr, byteCount);
				ptr[utf] = 0;
				NativePtr->BackendPlatformName = ptr;
				_managedAllocations.Add((IntPtr)ptr);
			}
		}

		public unsafe void SetIniFilename(string name)
		{
			if (NativePtr->IniFilename != null)
			{
				if (_managedAllocations.Contains((IntPtr)NativePtr->IniFilename))
				{
					Util.Free(NativePtr->IniFilename);
				}
				NativePtr->IniFilename = null;
			}
			if (name != null)
			{
				int byteCount = Encoding.UTF8.GetByteCount(name);
				byte* ptr = Util.Allocate(byteCount + 1);
				int utf = Util.GetUtf8(name, ptr, byteCount);
				ptr[utf] = 0;
				NativePtr->IniFilename = ptr;
				_managedAllocations.Add((IntPtr)ptr);
			}
		}
	}
	[Flags]
	public enum ImGuiItemFlags
	{
		None = 0,
		NoTabStop = 1,
		NoNav = 2,
		NoNavDefaultFocus = 4,
		ButtonRepeat = 8,
		AutoClosePopups = 0x10
	}
	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,
		F13 = 584,
		F14 = 585,
		F15 = 586,
		F16 = 587,
		F17 = 588,
		F18 = 589,
		F19 = 590,
		F20 = 591,
		F21 = 592,
		F22 = 593,
		F23 = 594,
		F24 = 595,
		Apostrophe = 596,
		Comma = 597,
		Minus = 598,
		Period = 599,
		Slash = 600,
		Semicolon = 601,
		Equal = 602,
		LeftBracket = 603,
		Backslash = 604,
		RightBracket = 605,
		GraveAccent = 606,
		CapsLock = 607,
		ScrollLock = 608,
		NumLock = 609,
		PrintScreen = 610,
		Pause = 611,
		Keypad0 = 612,
		Keypad1 = 613,
		Keypad2 = 614,
		Keypad3 = 615,
		Keypad4 = 616,
		Keypad5 = 617,
		Keypad6 = 618,
		Keypad7 = 619,
		Keypad8 = 620,
		Keypad9 = 621,
		KeypadDecimal = 622,
		KeypadDivide = 623,
		KeypadMultiply = 624,
		KeypadSubtract = 625,
		KeypadAdd = 626,
		KeypadEnter = 627,
		KeypadEqual = 628,
		AppBack = 629,
		AppForward = 630,
		GamepadStart = 631,
		GamepadBack = 632,
		GamepadFaceLeft = 633,
		GamepadFaceRight = 634,
		GamepadFaceUp = 635,
		GamepadFaceDown = 636,
		GamepadDpadLeft = 637,
		GamepadDpadRight = 638,
		GamepadDpadUp = 639,
		GamepadDpadDown = 640,
		GamepadL1 = 641,
		GamepadR1 = 642,
		GamepadL2 = 643,
		GamepadR2 = 644,
		GamepadL3 = 645,
		GamepadR3 = 646,
		GamepadLStickLeft = 647,
		GamepadLStickRight = 648,
		GamepadLStickUp = 649,
		GamepadLStickDown = 650,
		GamepadRStickLeft = 651,
		GamepadRStickRight = 652,
		GamepadRStickUp = 653,
		GamepadRStickDown = 654,
		MouseLeft = 655,
		MouseRight = 656,
		MouseMiddle = 657,
		MouseX1 = 658,
		MouseX2 = 659,
		MouseWheelX = 660,
		MouseWheelY = 661,
		ReservedForModCtrl = 662,
		ReservedForModShift = 663,
		ReservedForModAlt = 664,
		ReservedForModSuper = 665,
		COUNT = 666,
		ModNone = 0,
		ModCtrl = 4096,
		ModShift = 8192,
		ModAlt = 16384,
		ModSuper = 32768,
		ModMask = 61440,
		NamedKey_BEGIN = 512,
		NamedKey_END = 666,
		NamedKey_COUNT = 154,
		KeysData_SIZE = 154,
		KeysData_OFFSET = 512
	}
	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 IntPtr Ctx;

		public int DisplayStart;

		public int DisplayEnd;

		public int ItemsCount;

		public float ItemsHeight;

		public float StartPosY;

		public double StartSeekOffsetY;

		public unsafe void* TempData;
	}
	public struct ImGuiListClipperPtr
	{
		public unsafe ImGuiListClipper* NativePtr { get; }

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

		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 ref double StartSeekOffsetY => ref Unsafe.AsRef<double>(&NativePtr->StartSeekOffsetY);

		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 IncludeItemByIndex(int item_index)
		{
			ImGuiNative.ImGuiListClipper_IncludeItemByIndex(NativePtr, item_index);
		}

		public unsafe void SeekCursorForItem(int item_index)
		{
			ImGuiNative.ImGuiListClipper_SeekCursorForItem(NativePtr, item_index);
		}

		public unsafe bool Step()
		{
			byte b = ImGuiNative.ImGuiListClipper_Step(NativePtr);
			return b != 0;
		}
	}
	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 enum ImGuiMouseSource
	{
		Mouse,
		TouchScreen,
		Pen,
		COUNT
	}
	[Flags]
	public enum ImGuiMultiSelectFlags
	{
		None = 0,
		SingleSelect = 1,
		NoSelectAll = 2,
		NoRangeSelect = 4,
		NoAutoSelect = 8,
		NoAutoClear = 0x10,
		NoAutoClearOnReselect = 0x20,
		BoxSelect1d = 0x40,
		BoxSelect2d = 0x80,
		BoxSelectNoScroll = 0x100,
		ClearOnEscape = 0x200,
		ClearOnClickVoid = 0x400,
		ScopeWindow = 0x800,
		ScopeRect = 0x1000,
		SelectOnClick = 0x2000,
		SelectOnClickRelease = 0x4000,
		NavWrapX = 0x10000
	}
	public struct ImGuiMultiSelectIO
	{
		public ImVector Requests;

		public long RangeSrcItem;

		public long NavIdItem;

		public byte NavIdSelected;

		public byte RangeSrcReset;

		public int ItemsCount;
	}
	public struct ImGuiMultiSelectIOPtr
	{
		public unsafe ImGuiMultiSelectIO* NativePtr { get; }

		public unsafe ImPtrVector<ImGuiSelectionRequestPtr> Requests => new ImPtrVector<ImGuiSelectionRequestPtr>(NativePtr->Requests, Unsafe.SizeOf<ImGuiSelectionRequest>());

		public unsafe ref long RangeSrcItem => ref Unsafe.AsRef<long>(&NativePtr->RangeSrcItem);

		public unsafe ref long NavIdItem => ref Unsafe.AsRef<long>(&NativePtr->NavIdItem);

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

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

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

		public unsafe ImGuiMultiSelectIOPtr(ImGuiMultiSelectIO* nativePtr)
		{
			NativePtr = nativePtr;
		}

		public unsafe ImGuiMultiSelectIOPtr(IntPtr nativePtr)
		{
			NativePtr = (ImGuiMultiSelectIO*)(void*)nativePtr;
		}

		public unsafe static implicit operator ImGuiMultiSelectIOPtr(ImGuiMultiSelectIO* nativePtr)
		{
			return new ImGuiMultiSelectIOPtr(nativePtr);
		}

		public unsafe static implicit operator ImGuiMultiSelectIO*(ImGuiMultiSelectIOPtr wrappedPtr)
		{
			return wrappedPtr.NativePtr;
		}

		public static implicit operator ImGuiMultiSelectIOPtr(IntPtr nativePtr)
		{
			return new ImGuiMultiSelectIOPtr(nativePtr);
		}
	}
	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, ImGuiChildFlags child_flags, ImGuiWindowFlags window_flags);

		[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
		public static extern byte igBeginChild_ID(uint id, Vector2 size, ImGuiChildFlags child_flags, ImGuiWindowFlags window_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 static extern byte igBeginItemTooltip();

		[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 ImGuiMultiSelectIO* igBeginMultiSelect(ImGuiMultiSelectFlags flags, int selection_size, int items_count);

		[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 columns, ImGuiTableFlags flags, Vector2 outer_size, float inner_width);

		[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
		public static extern byte 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 static extern void igDebugFlashStyleColor(ImGuiCol idx);

		[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
		public unsafe static extern void igDebugLog(byte* fmt);

		[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
		public static extern void igDebugStartItemPicker();

		[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 dockspace_id, Vector2 size, ImGuiDockNodeFlags flags, ImGuiWindowClass* window_class);

		[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
		public unsafe static extern uint igDockSpaceOverViewport(uint dockspace_id, 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 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 unsafe static extern ImGuiMultiSelectIO* igEndMultiSelect();

		[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(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, float alpha_mul);

		[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 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_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 static extern uint igGetID_Int(int int_id);

		[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
		public unsafe static extern ImGuiIO* igGetIO();

		[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
		public static extern uint igGetItemID();

		[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 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 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 image_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 image_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 igIsItemToggledSelection();

		[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
		public static extern byte igIsItemVisible();

		[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
		public static extern byte igIsKeyChordPressed_Nil(ImGuiKey key_chord);

		[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_Nil(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 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 igPopItemFlag();

		[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 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 igPushItemFlag(ImGuiItemFlags option, byte enabled);

		[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 igSeparatorText(byte* label);

		[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 igSetItemDefaultFocus();

		[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
		public static extern void igSetItemKeyOwner_Nil(ImGuiKey key);

		[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
		public unsafe static extern void igSetItemTooltip(byte* fmt);

		[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 igSetNextItemAllowOverlap();

		[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
		public static extern void igSetNextItemOpen(byte is_open, ImGuiCond cond);

		[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
		public static extern void igSetNextItemSelectionUserData(long selection_user_data);

		[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
		public static extern void igSetNextItemShortcut(ImGuiKey key_chord, ImGuiInputFlags flags);

		[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
		public static extern void igSetNextItemStorageID(uint storage_id);

		[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 static extern byte igShortcut_Nil(ImGuiKey key_chord, ImGuiInputFlags flags);

		[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 igShowIDStackToolWindow(byte* p_open);

		[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
		public unsafe static extern void igShowMetricsWindow(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 void igTableAngledHeadersRow();

		[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 igTableGetHoveredColumn();

		[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 byte igTextLink(byte* label);

		[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
		public unsafe static extern void igTextLinkOpenURL(byte* label, byte* url);

		[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_AddDrawList(ImDrawData* self, ImDrawList* draw_list);

		[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_AddConcavePolyFilled(ImDrawList* self, Vector2* points, int num_points, uint col);

		[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_AddEllipse(ImDrawList* self, Vector2 center, Vector2 radius, uint col, float rot, int num_segments, float thickness);

		[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
		public unsafe static extern void ImDrawList_AddEllipseFilled(ImDrawList* self, Vector2 center, Vector2 radius, uint col, float rot, int num_segments);

		[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_PathEllipticalArcTo(ImDrawList* self, Vector2 center, Vector2 radius, float rot, float a_min, float a_max, int num_segments);

		[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
		public unsafe static extern void ImDrawList_PathFillConcave(ImDrawList* self, uint col);

		[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_data_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_data_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_AddMouseSourceEvent(ImGuiIO* self, ImGuiMouseSource source);

		[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 wheel_x, float wheel_y);

		[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
		public unsafe static extern void ImGuiIO_ClearEventsQueue(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_ClearInputMouse(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 ImGuiListClipper* ImGuiListClipper_ImGuiListClipper();

		[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
		public unsafe static extern void ImGuiListClipper_IncludeItemByIndex(ImGuiListClipper* self, int item_index);

		[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
		public unsafe static extern void ImGuiListClipper_IncludeItemsByIndex(ImGuiListClipper* self, int item_begin, int item_end);

		[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
		public unsafe static extern void ImGuiListClipper_SeekCursorForItem(ImGuiListClipper* self, int item_index);

		[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 ImGuiSelectionBasicStorage_ApplyRequests(ImGuiSelectionBasicStorage* self, ImGuiMultiSelectIO* ms_io);

		[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
		public unsafe static extern void ImGuiSelectionBasicStorage_Clear(ImGuiSelectionBasicStorage* self);

		[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
		public unsafe static extern byte ImGuiSelectionBasicStorage_Contains(ImGuiSelectionBasicStorage* self, uint id);

		[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
		public unsafe static extern void ImGuiSelectionBasicStorage_destroy(ImGuiSelectionBasicStorage* self);

		[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
		public unsafe static extern byte ImGuiSelectionBasicStorage_GetNextSelectedItem(ImGuiSelectionBasicStorage* self, void** opaque_it, uint* out_id);

		[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
		public unsafe static extern uint ImGuiSelectionBasicStorage_GetStorageIdFromIndex(ImGuiSelectionBasicStorage* self, int idx);

		[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
		public unsafe static extern ImGuiSelectionBasicStorage* ImGuiSelectionBasicStorage_ImGuiSelectionBasicStorage();

		[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
		public unsafe static extern void ImGuiSelectionBasicStorage_SetItemSelected(ImGuiSelectionBasicStorage* self, uint id, byte selected);

		[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
		public unsafe static extern void ImGuiSelectionBasicStorage_Swap(ImGuiSelectionBasicStorage* self, ImGuiSelectionBasicStorage* r);

		[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
		public unsafe static extern void ImGuiSelectionExternalStorage_ApplyRequests(ImGuiSelectionExternalStorage* self, ImGuiMultiSelectIO* ms_io);

		[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
		public unsafe static extern void ImGuiSelectionExternalStorage_destroy(ImGuiSelectionExternalStorage* self);

		[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
		public unsafe static extern ImGuiSelectionExternalStorage* ImGuiSelectionExternalStorage_ImGuiSelectionExternalStorage();

		[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);

		[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
		public unsafe static extern ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePair_Float(uint _key, float _val);

		[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
		public unsafe static extern ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePair_Ptr(uint _key, void* _val);

		[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);

		[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
		public unsafe static extern void ImGuiPlatformIO_Set_Platform_GetWindowPos(ImGuiPlatformIO* platform_io, IntPtr funcPtr);

		[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
		public unsafe static extern void ImGuiPlatformIO_Set_Platform_GetWindowSize(ImGuiPlatformIO* platform_io, IntPtr funcPtr);
	}
	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(ReadOnlySpan<char> type)
		{
			int num = 0;
			byte* ptr;
			if (type != null)
			{
				num = Encoding.UTF8.GetByteCount(type);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(type, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.ImGuiPayload_IsDataType(NativePtr, ptr);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe bool IsDataType(string type)
		{
			int num = 0;
			byte* ptr;
			if (type != null)
			{
				num = Encoding.UTF8.GetByteCount(type);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(type, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.ImGuiPayload_IsDataType(NativePtr, ptr);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe bool IsDelivery()
		{
			byte b = ImGuiNative.ImGuiPayload_IsDelivery(NativePtr);
			return b != 0;
		}

		public unsafe bool IsPreview()
		{
			byte b = ImGuiNative.ImGuiPayload_IsPreview(NativePtr);
			return b != 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>((void*)(&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 unsafe void* PlatformHandle;
	}
	public struct ImGuiPlatformMonitorPtr
	{
		public unsafe ImGuiPlatformMonitor* NativePtr { get; }

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

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

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

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

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

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

		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,
		NoReopen = 0x20,
		NoOpenOverExistingPopup = 0x80,
		NoOpenOverItems = 0x100,
		AnyPopupId = 0x400,
		AnyPopupLevel = 0x800,
		AnyPopup = 0xC00
	}
	[Flags]
	public enum ImGuiSelectableFlags
	{
		None = 0,
		NoAutoClosePopups = 1,
		SpanAllColumns = 2,
		AllowDoubleClick = 4,
		Disabled = 8,
		AllowOverlap = 0x10,
		Highlight = 0x20
	}
	public struct ImGuiSelectionBasicStorage
	{
		public int Size;

		public byte PreserveOrder;

		public unsafe void* UserData;

		public IntPtr AdapterIndexToStorageId;

		public int _SelectionOrder;

		public ImGuiStorage _Storage;
	}
	public struct ImGuiSelectionBasicStoragePtr
	{
		public unsafe ImGuiSelectionBasicStorage* NativePtr { get; }

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

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

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

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

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

		public unsafe ref ImGuiStorage _Storage => ref Unsafe.AsRef<ImGuiStorage>(&NativePtr->_Storage);

		public unsafe ImGuiSelectionBasicStoragePtr(ImGuiSelectionBasicStorage* nativePtr)
		{
			NativePtr = nativePtr;
		}

		public unsafe ImGuiSelectionBasicStoragePtr(IntPtr nativePtr)
		{
			NativePtr = (ImGuiSelectionBasicStorage*)(void*)nativePtr;
		}

		public unsafe static implicit operator ImGuiSelectionBasicStoragePtr(ImGuiSelectionBasicStorage* nativePtr)
		{
			return new ImGuiSelectionBasicStoragePtr(nativePtr);
		}

		public unsafe static implicit operator ImGuiSelectionBasicStorage*(ImGuiSelectionBasicStoragePtr wrappedPtr)
		{
			return wrappedPtr.NativePtr;
		}

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

		public unsafe void ApplyRequests(ImGuiMultiSelectIOPtr ms_io)
		{
			ImGuiMultiSelectIO* nativePtr = ms_io.NativePtr;
			ImGuiNative.ImGuiSelectionBasicStorage_ApplyRequests(NativePtr, nativePtr);
		}

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

		public unsafe bool Contains(uint id)
		{
			byte b = ImGuiNative.ImGuiSelectionBasicStorage_Contains(NativePtr, id);
			return b != 0;
		}

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

		public unsafe bool GetNextSelectedItem(ref void* opaque_it, out uint out_id)
		{
			fixed (void** opaque_it2 = &opaque_it)
			{
				fixed (uint* out_id2 = &out_id)
				{
					byte b = ImGuiNative.ImGuiSelectionBasicStorage_GetNextSelectedItem(NativePtr, opaque_it2, out_id2);
					return b != 0;
				}
			}
		}

		public unsafe uint GetStorageIdFromIndex(int idx)
		{
			return ImGuiNative.ImGuiSelectionBasicStorage_GetStorageIdFromIndex(NativePtr, idx);
		}

		public unsafe void SetItemSelected(uint id, bool selected)
		{
			byte selected2 = (byte)(selected ? 1 : 0);
			ImGuiNative.ImGuiSelectionBasicStorage_SetItemSelected(NativePtr, id, selected2);
		}

		public unsafe void Swap(ImGuiSelectionBasicStoragePtr r)
		{
			ImGuiSelectionBasicStorage* nativePtr = r.NativePtr;
			ImGuiNative.ImGuiSelectionBasicStorage_Swap(NativePtr, nativePtr);
		}
	}
	public struct ImGuiSelectionExternalStorage
	{
		public unsafe void* UserData;

		public IntPtr AdapterSetItemSelected;
	}
	public struct ImGuiSelectionExternalStoragePtr
	{
		public unsafe ImGuiSelectionExternalStorage* NativePtr { get; }

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

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

		public unsafe ImGuiSelectionExternalStoragePtr(ImGuiSelectionExternalStorage* nativePtr)
		{
			NativePtr = nativePtr;
		}

		public unsafe ImGuiSelectionExternalStoragePtr(IntPtr nativePtr)
		{
			NativePtr = (ImGuiSelectionExternalStorage*)(void*)nativePtr;
		}

		public unsafe static implicit operator ImGuiSelectionExternalStoragePtr(ImGuiSelectionExternalStorage* nativePtr)
		{
			return new ImGuiSelectionExternalStoragePtr(nativePtr);
		}

		public unsafe static implicit operator ImGuiSelectionExternalStorage*(ImGuiSelectionExternalStoragePtr wrappedPtr)
		{
			return wrappedPtr.NativePtr;
		}

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

		public unsafe void ApplyRequests(ImGuiMultiSelectIOPtr ms_io)
		{
			ImGuiMultiSelectIO* nativePtr = ms_io.NativePtr;
			ImGuiNative.ImGuiSelectionExternalStorage_ApplyRequests(NativePtr, nativePtr);
		}

		public unsafe void Destroy()
		{
			ImGuiNative.ImGuiSelectionExternalStorage_destroy(NativePtr);
		}
	}
	public struct ImGuiSelectionRequest
	{
		public ImGuiSelectionRequestType Type;

		public byte Selected;

		public sbyte RangeDirection;

		public long RangeFirstItem;

		public long RangeLastItem;
	}
	public struct ImGuiSelectionRequestPtr
	{
		public unsafe ImGuiSelectionRequest* NativePtr { get; }

		public unsafe ref ImGuiSelectionRequestType Type => ref Unsafe.AsRef<ImGuiSelectionRequestType>(&NativePtr->Type);

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

		public unsafe ref sbyte RangeDirection => ref Unsafe.AsRef<sbyte>(&NativePtr->RangeDirection);

		public unsafe ref long RangeFirstItem => ref Unsafe.AsRef<long>(&NativePtr->RangeFirstItem);

		public unsafe ref long RangeLastItem => ref Unsafe.AsRef<long>(&NativePtr->RangeLastItem);

		public unsafe ImGuiSelectionRequestPtr(ImGuiSelectionRequest* nativePtr)
		{
			NativePtr = nativePtr;
		}

		public unsafe ImGuiSelectionRequestPtr(IntPtr nativePtr)
		{
			NativePtr = (ImGuiSelectionRequest*)(void*)nativePtr;
		}

		public unsafe static implicit operator ImGuiSelectionRequestPtr(ImGuiSelectionRequest* nativePtr)
		{
			return new ImGuiSelectionRequestPtr(nativePtr);
		}

		public unsafe static implicit operator ImGuiSelectionRequest*(ImGuiSelectionRequestPtr wrappedPtr)
		{
			return wrappedPtr.NativePtr;
		}

		public static implicit operator ImGuiSelectionRequestPtr(IntPtr nativePtr)
		{
			return new ImGuiSelectionRequestPtr(nativePtr);
		}
	}
	public enum ImGuiSelectionRequestType
	{
		None,
		SetAll,
		SetRange
	}
	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>((void*)(&NativePtr->Pos));

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

		public unsafe ref Vector2 DesiredSize => ref Unsafe.AsRef<Vector2>((void*)(&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,
		WrapAround = 0x100,
		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;
			byte b = ImGuiNative.ImGuiStorage_GetBool(NativePtr, key, default_val);
			return b != 0;
		}

		public unsafe bool GetBool(uint key, bool default_val)
		{
			byte default_val2 = (byte)(default_val ? 1 : 0);
			byte b = ImGuiNative.ImGuiStorage_GetBool(NativePtr, key, default_val2);
			return b != 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)
		{
			void* ptr = ImGuiNative.ImGuiStorage_GetVoidPtr(NativePtr, key);
			return (IntPtr)ptr;
		}

		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 float TabBarBorderSize;

		public float TabBarOverlineSize;

		public float TableAngledHeadersAngle;

		public Vector2 TableAngledHeadersTextAlign;

		public ImGuiDir ColorButtonPosition;

		public Vector2 ButtonTextAlign;

		public Vector2 SelectableTextAlign;

		public float SeparatorTextBorderSize;

		public Vector2 SeparatorTextAlign;

		public Vector2 SeparatorTextPadding;

		public Vector2 DisplayWindowPadding;

		public Vector2 DisplaySafeAreaPadding;

		public float DockingSeparatorSize;

		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 Vector4 Colors_55;

		public Vector4 Colors_56;

		public Vector4 Colors_57;

		public float HoverStationaryDelay;

		public float HoverDelayShort;

		public float HoverDelayNormal;

		public ImGuiHoveredFlags HoverFlagsForTooltipMouse;

		public ImGuiHoveredFlags HoverFlagsForTooltipNav;
	}
	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>((void*)(&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>((void*)(&NativePtr->WindowMinSize));

		public unsafe ref Vector2 WindowTitleAlign => ref Unsafe.AsRef<Vector2>((void*)(&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>((void*)(&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>((void*)(&NativePtr->ItemSpacing));

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

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

		public unsafe ref Vector2 TouchExtraPadding => ref Unsafe.AsRef<Vector2>((void*)(&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 float TabBarBorderSize => ref Unsafe.AsRef<float>(&NativePtr->TabBarBorderSize);

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

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

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

		public unsafe ref ImGuiDir ColorButtonPosition => ref Unsafe.AsRef<ImGuiDir>(&NativePtr->ColorButtonPosition);

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

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

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

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

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

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

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

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

		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, 58);

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

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

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

		public unsafe ref ImGuiHoveredFlags HoverFlagsForTooltipMouse => ref Unsafe.AsRef<ImGuiHoveredFlags>(&NativePtr->HoverFlagsForTooltipMouse);

		public unsafe ref ImGuiHoveredFlags HoverFlagsForTooltipNav => ref Unsafe.AsRef<ImGuiHoveredFlags>(&NativePtr->HoverFlagsForTooltipNav);

		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,
		TabBorderSize,
		TabBarBorderSize,
		TabBarOverlineSize,
		TableAngledHeadersAngle,
		TableAngledHeadersTextAlign,
		ButtonTextAlign,
		SelectableTextAlign,
		SeparatorTextBorderSize,
		SeparatorTextAlign,
		SeparatorTextPadding,
		DockingSeparatorSize,
		COUNT
	}
	[Flags]
	public enum ImGuiTabBarFlags
	{
		None = 0,
		Reorderable = 1,
		AutoSelectNewTabs = 2,
		TabListPopupButton = 4,
		NoCloseWithMiddleMouseButton = 8,
		NoTabListScrollingButtons = 0x10,
		NoTooltip = 0x20,
		DrawSelectedOverline = 0x40,
		FittingPolicyResizeDown = 0x80,
		FittingPolicyScroll = 0x100,
		FittingPolicyMask = 0x180,
		FittingPolicyDefault = 0x80
	}
	[Flags]
	public enum ImGuiTabItemFlags
	{
		None = 0,
		UnsavedDocument = 1,
		SetSelected = 2,
		NoCloseWithMiddleMouseButton = 4,
		NoPushId = 8,
		NoTooltip = 0x10,
		NoReorder = 0x20,
		Leading = 0x40,
		Trailing = 0x80,
		NoAssumedClosure = 0x100
	}
	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,
		AngledHeader = 0x40000,
		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,
		HighlightHoveredColumn = 0x10000000,
		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(ReadOnlySpan<char> str)
		{
			int num = 0;
			byte* ptr;
			if (str != null)
			{
				num = Encoding.UTF8.GetByteCount(str);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			ImGuiNative.ImGuiTextBuffer_append(NativePtr, ptr, ptr + num);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
		}

		public unsafe void append(string str)
		{
			int num = 0;
			byte* ptr;
			if (str != null)
			{
				num = Encoding.UTF8.GetByteCount(str);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(str, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			ImGuiNative.ImGuiTextBuffer_append(NativePtr, ptr, ptr + num);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
		}

		public unsafe void appendf(ReadOnlySpan<char> fmt)
		{
			int num = 0;
			byte* ptr;
			if (fmt != null)
			{
				num = Encoding.UTF8.GetByteCount(fmt);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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 void appendf(string fmt)
		{
			int num = 0;
			byte* ptr;
			if (fmt != null)
			{
				num = Encoding.UTF8.GetByteCount(fmt);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				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()
		{
			byte* ptr = ImGuiNative.ImGuiTextBuffer_begin(NativePtr);
			return Util.StringFromPtr(ptr);
		}

		public unsafe string c_str()
		{
			byte* ptr = ImGuiNative.ImGuiTextBuffer_c_str(NativePtr);
			return Util.StringFromPtr(ptr);
		}

		public unsafe void clear()
		{
			ImGuiNative.ImGuiTextBuffer_clear(NativePtr);
		}

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

		public unsafe bool empty()
		{
			byte b = ImGuiNative.ImGuiTextBuffer_empty(NativePtr);
			return b != 0;
		}

		public unsafe string end()
		{
			byte* ptr = ImGuiNative.ImGuiTextBuffer_end(NativePtr);
			return Util.StringFromPtr(ptr);
		}

		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;
			if (num > 2048)
			{
				ptr = Util.Allocate(num + 1);
			}
			else
			{
				byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
				ptr = ptr2;
			}
			int utf = Util.GetUtf8("Filter(inc,-exc)", ptr, num);
			ptr[utf] = 0;
			float width = 0f;
			byte b = ImGuiNative.ImGuiTextFilter_Draw(NativePtr, ptr, width);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe bool Draw(ReadOnlySpan<char> label)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			float width = 0f;
			byte b = ImGuiNative.ImGuiTextFilter_Draw(NativePtr, ptr, width);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe bool Draw(string label)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			float width = 0f;
			byte b = ImGuiNative.ImGuiTextFilter_Draw(NativePtr, ptr, width);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe bool Draw(ReadOnlySpan<char> label, float width)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.ImGuiTextFilter_Draw(NativePtr, ptr, width);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe bool Draw(string label, float width)
		{
			int num = 0;
			byte* ptr;
			if (label != null)
			{
				num = Encoding.UTF8.GetByteCount(label);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(label, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.ImGuiTextFilter_Draw(NativePtr, ptr, width);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe bool IsActive()
		{
			byte b = ImGuiNative.ImGuiTextFilter_IsActive(NativePtr);
			return b != 0;
		}

		public unsafe bool PassFilter(ReadOnlySpan<char> text)
		{
			int num = 0;
			byte* ptr;
			if (text != null)
			{
				num = Encoding.UTF8.GetByteCount(text);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(text, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.ImGuiTextFilter_PassFilter(NativePtr, ptr, ptr + num);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 0;
		}

		public unsafe bool PassFilter(string text)
		{
			int num = 0;
			byte* ptr;
			if (text != null)
			{
				num = Encoding.UTF8.GetByteCount(text);
				if (num > 2048)
				{
					ptr = Util.Allocate(num + 1);
				}
				else
				{
					byte* ptr2 = stackalloc byte[(int)(uint)(num + 1)];
					ptr = ptr2;
				}
				int utf = Util.GetUtf8(text, ptr, num);
				ptr[utf] = 0;
			}
			else
			{
				ptr = null;
			}
			byte b = ImGuiNative.ImGuiTextFilter_PassFilter(NativePtr, ptr, ptr + num);
			if (num > 2048)
			{
				Util.Free(ptr);
			}
			return b != 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()
		{
			byte b = ImGuiNative.ImGuiTextRange_empty(NativePtr);
			return b != 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,
		AllowOverlap = 4,
		NoTreePushOnOpen = 8,
		NoAutoOpenOnLog = 0x10,
		DefaultOpen = 0x20,
		OpenOnDoubleClick = 0x40,
		OpenOnArrow = 0x80,
		Leaf = 0x100,
		Bullet = 0x200,
		FramePadding = 0x400,
		SpanAvailWidth = 0x800,
		SpanFullWidth = 0x1000,
		SpanTextWidth = 0x2000,
		SpanAllColumns = 0x4000,
		NavLeftJumpsBackHere = 0x8000,
		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>((void*)(&NativePtr->Pos));

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

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

		public unsafe ref Vector2 WorkSize => ref Unsafe.AsRef<Vector2>((void*)(&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()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			Vector2 result = default(Vector2);
			ImGuiNative.ImGuiViewport_GetCenter(&result, NativePtr);
			return result;
		}

		public unsafe Vector2 GetWorkCenter()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			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,
		NoAutoMerge = 0x200,
		TopMost = 0x400,
		CanHostOtherWindows = 0x800,
		IsMinimized = 0x1000,
		IsFocused = 0x2000
	}
	public struct ImGuiWindowClass
	{
		public uint ClassId;

		public uint ParentViewportId;

		public uint FocusRouteParentWindowId;

		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 uint FocusRouteParentWindowId => ref Unsafe.AsRef<uint>(&NativePtr->FocusRouteParentWindowId);

		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,
		NoNavInputs = 0x10000,
		NoNavFocus = 0x20000,
		UnsavedDocument = 0x40000,
		NoDocking = 0x80000,
		NoNav = 0x30000,
		NoDecoration = 0x2B,
		NoInputs = 0x30200,
		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);
		}
	}
	[Flags]
	public enum ImGuiModFlags
	{
		None = 0,
		Ctrl = 1,
		Shift = 2,
		Alt = 4,
		Super = 8
	}
	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 ImVector(int size, int capacity, IntPtr data)
		{
			Size = size;
			Capacity = capacity;
			Data = 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(ReadOnlySpan<char> s, int start, int length)
		{
			if (start < 0 || length < 0 || start + length > s.Length)
			{
				throw new ArgumentOutOfRangeException();
			}
			if (s.Length == 0)
			{
				return 0;
			}
			fixed (char* ptr = s)
			{
				return Encoding.UTF8.GetByteCount(ptr + start, length);
			}
		}

		internal unsafe static int GetUtf8(ReadOnlySpan<char> s, byte* utf8Bytes, int utf8ByteCount)
		{
			if (s.IsEmpty)
			{
				return 0;
			}
			fixed (char* chars = s)
			{
				return Encoding.UTF8.GetBytes(chars, s.Length, utf8Bytes, utf8ByteCount);
			}
		}

		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(ReadOnlySpan<char> s, int start, int length, byte* utf8Bytes, int utf8ByteCount)
		{
			if (start < 0 || length < 0 || start + length > s.Length)
			{
				throw new ArgumentOutOfRangeException();
			}
			if (s.Length == 0)
			{
				return 0;
			}
			fixed (char* ptr = s)
			{
				return Encoding.UTF8.GetBytes(ptr + start, length, utf8Bytes, utf8ByteCount);
			}
		}
	}
}
namespace UBImGui
{
	[BepInPlugin("com.snosz.ubimgui", "UBImGui", "1.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		internal static AssetBundle resourcesBundle;

		private void Awake()
		{
			byte[] resources = Resource1.resources;
			resourcesBundle = AssetBundle.LoadFromMemory(resources);
			resourcesBundle.LoadAllAssets();
		}

		private void Start()
		{
		}
	}
	[GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "18.0.0.0")]
	[DebuggerNonUserCode]
	[CompilerGenerated]
	internal class Resource1
	{
		private static ResourceManager resourceMan;

		private static CultureInfo resourceCulture;

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		internal static ResourceManager ResourceManager
		{
			get
			{
				if (resourceMan == null)
				{
					ResourceManager resourceManager = new ResourceManager("UBImGui.Resource1", typeof(Resource1).Assembly);
					resourceMan = resourceManager;
				}
				return resourceMan;
			}
		}

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		internal static CultureInfo Culture
		{
			get
			{
				return resourceCulture;
			}
			set
			{
				resourceCulture = value;
			}
		}

		internal static byte[] resources
		{
			get
			{
				object @object = ResourceManager.GetObject("resources", resourceCulture);
				return (byte[])@object;
			}
		}

		internal Resource1()
		{
		}
	}
	[CreateAssetMenu(fileName = "ImGui Cursor", menuName = "UB ImGui/Cursor")]
	public class ImGuiCursorAsset : ScriptableObject
	{
		[Serializable]
		public struct CursorShape
		{
			public Texture2D texture;

			public Vector2 hotspot;
		}

		[Tooltip("Default.")]
		public CursorShape Arrow;

		[Tooltip("When hovering over InputText.")]
		public CursorShape TextInput;

		[Tooltip("(Unused by ImGui functions)")]
		public CursorShape ResizeAll;

		[Tooltip("When hovering over an horizontal border")]
		public CursorShape ResizeEW;

		[Tooltip("When hovering over a vertical border or column")]
		public CursorShape ResizeNS;

		[Tooltip("When hovering over the bottom-left corner of a window")]
		public CursorShape ResizeNESW;

		[Tooltip("When hovering over the bottom-right corner of a window")]
		public CursorShape ResizeNWSE;

		[Tooltip("(Unused by ImGui functions. Use for e.g. hyperlinks)")]
		public CursorShape Hand;

		[Tooltip("When hovering something with disabled interaction.")]
		public CursorShape NotAllowed;

		public ref CursorShape this[ImGuiMouseCursor cursor] => cursor switch
		{
			ImGuiMouseCursor.Arrow => ref Arrow, 
			ImGuiMouseCursor.TextInput => ref TextInput, 
			ImGuiMouseCursor.ResizeAll => ref ResizeAll, 
			ImGuiMouseCursor.ResizeEW => ref ResizeEW, 
			ImGuiMouseCursor.ResizeNS => ref ResizeNS, 
			ImGuiMouseCursor.ResizeNESW => ref ResizeNESW, 
			ImGuiMouseCursor.ResizeNWSE => ref ResizeNWSE, 
			ImGuiMouseCursor.Hand => ref Hand, 
			ImGuiMouseCursor.NotAllowed => ref NotAllowed, 
			_ => ref Arrow, 
		};
	}
	[CreateAssetMenu(fileName = "ImGui Font Atlas", menuName = "UB ImGui/Font Atlas")]
	public class ImGuiFontAsset : ScriptableObject
	{
		public FontSettings[] fontSettings;
	}
	[CreateAssetMenu(fileName = "ImGui Style", menuName = "UB ImGui/Style")]
	public class ImGuiStyleAsset : ScriptableObject
	{
		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 float TabBarBorderSize;

		public float TabBarOverlineSize;

		public float TableAngledHeadersAngle;

		public Vector2 TableAngledHeadersTextAlign;

		public ImGuiDir ColorButtonPosition;

		public Vector2 ButtonTextAlign;

		public Vector2 SelectableTextAlign;

		public float SeparatorTextBorderSize;

		public Vector2 SeparatorTextAlign;

		public Vector2 SeparatorTextPadding;

		public Vector2 DisplayWindowPadding;

		public Vector2 DisplaySafeAreaPadding;

		public float DockingSeparatorSize;

		public float MouseCursorScale;

		public bool AntiAliasedLines;

		public bool AntiAliasedLinesUseTex;

		public bool AntiAliasedFill;

		public float CurveTessellationTol;

		public float CircleTessellationMaxError;

		public float HoverStationaryDelay;

		public float HoverDelayShort;

		public float HoverDelayNormal;

		public ImGuiHoveredFlags HoverFlagsForTooltipMouse;

		public ImGuiHoveredFlags HoverFlagsForTooltipNav;

		[HideInInspector]
		public Color[] Colors = (Color[])(object)new Color[58];

		public void ApplyTo(ImGuiStylePtr style)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_033f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0344: Unknown result type (might be due to invalid IL or missing references)
			//IL_0349: Unknown result type (might be due to invalid IL or missing references)
			style.Alpha = Alpha;
			style.DisabledAlpha = DisabledAlpha;
			style.WindowPadding = WindowPadding;
			style.WindowRounding = WindowRounding;
			style.WindowBorderSize = WindowBorderSize;
			style.WindowMinSize = WindowMinSize;
			style.WindowTitleAlign = WindowTitleAlign;
			style.WindowMenuButtonPosition = WindowMenuButtonPosition;
			style.ChildRounding = ChildRounding;
			style.ChildBorderSize = ChildBorderSize;
			style.PopupRounding = PopupRounding;
			style.PopupBorderSize = PopupBorderSize;
			style.FramePadding = FramePadding;
			style.FrameRounding = FrameRounding;
			style.FrameBorderSize = FrameBorderSize;
			style.ItemSpacing = ItemSpacing;
			style.ItemInnerSpacing = ItemInnerSpacing;
			style.CellPadding = CellPadding;
			style.TouchExtraPadding = TouchExtraPadding;
			style.IndentSpacing = IndentSpacing;
			style.ColumnsMinSpacing = ColumnsMinSpacing;
			style.ScrollbarSize = ScrollbarSize;
			style.ScrollbarRounding = ScrollbarRounding;
			style.GrabMinSize = GrabMinSize;
			style.GrabRounding = GrabRounding;
			style.LogSliderDeadzone = LogSliderDeadzone;
			style.TabRounding = TabRounding;
			style.TabBorderSize = TabBorderSize;
			style.TabMinWidthForCloseButton = TabMinWidthForCloseButton;
			style.TabBarBorderSize = TabBarBorderSize;
			style.TabBarOverlineSize = TabBarOverlineSize;
			style.TableAngledHeadersAngle = TableAngledHeadersAngle;
			style.TableAngledHeadersTextAlign = TableAngledHeadersTextAlign;
			style.ColorButtonPosition = ColorButtonPosition;
			style.ButtonTextAlign = ButtonTextAlign;
			style.SelectableTextAlign = SelectableTextAlign;
			style.SeparatorTextBorderSize = SeparatorTextBorderSize;
			style.SeparatorTextAlign = SeparatorTextAlign;
			style.SeparatorTextPadding = SeparatorTextPadding;
			style.DisplayWindowPadding = DisplayWindowPadding;
			style.DisplaySafeAreaPadding = DisplaySafeAreaPadding;
			style.DockingSeparatorSize = DockingSeparatorSize;
			style.MouseCursorScale = MouseCursorScale;
			style.AntiAliasedLines = AntiAliasedLines;
			style.AntiAliasedLinesUseTex = AntiAliasedLinesUseTex;
			style.AntiAliasedFill = AntiAliasedFill;
			style.CurveTessellationTol = CurveTessellationTol;
			style.CircleTessellationMaxError = CircleTessellationMaxError;
			style.HoverStationaryDelay = HoverStationaryDelay;
			style.HoverDelayShort = HoverDelayShort;
			style.HoverDelayNormal = HoverDelayNormal;
			style.HoverFlagsForTooltipMouse = HoverFlagsForTooltipMouse;
			style.HoverFlagsForTooltipNav = HoverFlagsForTooltipNav;
			for (int i = 0; i < Colors.Length; i++)
			{
				style.Colors[i] = Color.op_Implicit(Colors[i]);
			}
		}

		public void CopyFrom(ImGuiStylePtr style)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_033e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0343: Unknown result type (might be due to invalid IL or missing references)
			//IL_0348: Unknown result type (might be due to invalid IL or missing references)
			Alpha = style.Alpha;
			DisabledAlpha = style.DisabledAlpha;
			WindowPadding = style.WindowPadding;
			WindowRounding = style.WindowRounding;
			WindowBorderSize = style.WindowBorderSize;
			WindowMinSize = style.WindowMinSize;
			WindowTitleAlign = style.WindowTitleAlign;
			WindowMenuButtonPosition = style.WindowMenuButtonPosition;
			ChildRounding = style.ChildRounding;
			ChildBorderSize = style.ChildBorderSize;
			PopupRounding = style.PopupRounding;
			PopupBorderSize = style.PopupBorderSize;
			FramePadding = style.FramePadding;
			FrameRounding = style.FrameRounding;
			FrameBorderSize = style.FrameBorderSize;
			ItemSpacing = style.ItemSpacing;
			ItemInnerSpacing = style.ItemInnerSpacing;
			CellPadding = style.CellPadding;
			TouchExtraPadding = style.TouchExtraPadding;
			IndentSpacing = style.IndentSpacing;
			ColumnsMinSpacing = style.ColumnsMinSpacing;
			ScrollbarSize = style.ScrollbarSize;
			ScrollbarRounding = style.ScrollbarRounding;
			GrabMinSize = style.GrabMinSize;
			GrabRounding = style.GrabRounding;
			LogSliderDeadzone = style.LogSliderDeadzone;
			TabRounding = style.TabRounding;
			TabBorderSize = style.TabBorderSize;
			TabMinWidthForCloseButton = style.TabMinWidthForCloseButton;
			TabBarBorderSize = style.TabBarBorderSize;
			TabBarOverlineSize = style.TabBarOverlineSize;
			TableAngledHeadersAngle = style.TableAngledHeadersAngle;
			TableAngledHeadersTextAlign = style.TableAngledHeadersTextAlign;
			ColorButtonPosition = style.ColorButtonPosition;
			ButtonTextAlign = style.ButtonTextAlign;
			SelectableTextAlign = style.SelectableTextAlign;
			SeparatorTextBorderSize = style.SeparatorTextBorderSize;
			SeparatorTextAlign = style.SeparatorTextAlign;
			SeparatorTextPadding = style.SeparatorTextPadding;
			DisplayWindowPadding = style.DisplayWindowPadding;
			DisplaySafeAreaPadding = style.DisplaySafeAreaPadding;
			DockingSeparatorSize = style.DockingSeparatorSize;
			MouseCursorScale = style.MouseCursorScale;
			AntiAliasedLines = style.AntiAliasedLines;
			AntiAliasedLinesUseTex = style.AntiAliasedLinesUseTex;
			AntiAliasedFill = style.AntiAliasedFill;
			CurveTessellationTol = style.CurveTessellationTol;
			CircleTessellationMaxError = style.CircleTessellationMaxError;
			HoverStationaryDelay = style.HoverStationaryDelay;
			HoverDelayShort = style.HoverDelayShort;
			HoverDelayNormal = style.HoverDelayNormal;
			HoverFlagsForTooltipMouse = style.HoverFlagsForTooltipMouse;
			HoverFlagsForTooltipNav = style.HoverFlagsForTooltipNav;
			for (int i = 0; i < Colors.Length; i++)
			{
				Colors[i] = Color.op_Implicit(style.Colors[i]);
			}
		}

		public void Reset()
		{
			IntPtr currentContext = ImGui.GetCurrentContext();
			IntPtr intPtr = ImGui.CreateContext();
			ImGui.SetCurrentContext(intPtr);
			CopyFrom(ImGui.GetStyle());
			if (currentContext != IntPtr.Zero)
			{
				ImGui.SetCurrentContext(currentContext);
			}
			ImGui.DestroyContext(intPtr);
		}

		public static ImGuiStyleAsset Default()
		{
			ImGuiStyleAsset imGuiStyleAsset = ScriptableObject.CreateInstance<ImGuiStyleAsset>();
			imGuiStyleAsset.Reset();
			return imGuiStyleAsset;
		}
	}
	[CreateAssetMenu(fileName = "UBImGui Settings", menuName = "UB ImGui/Settings")]
	public class UBImGuiSettings : ScriptableObject
	{
		public enum InputMode
		{
			InputManager
		}

		public ImGuiStyleAsset styleAsset;

		public ImGuiFontAsset fontAsset;

		public ImGuiCursorAsset cursorAsset;

		[Header("UB ImGui Settings")]
		public bool renderInFront;

		public InputMode inputMode;

		[Header("Dear ImGui Settings")]
		public DearImGuiIOConfig dearImGuiConfig;

		[TextArea(3, 20)]
		public string iniSettings;

		public uint iniSettingsSize;

		internal bool IsDefault;

		internal bool IsTemp;

		internal bool IsDirt;

		public void ApplyTo(ImGuiStylePtr style, ImGuiIOPtr io)
		{
			styleAsset?.ApplyTo(style);
			dearImGuiConfig.ApplyTo(io);
		}

		public void Reset()
		{
			renderInFront = false;
			inputMode = InputMode.InputManager;
			dearImGuiConfig.Reset();
			iniSettings = "";
			iniSettingsSize = 0u;
		}

		public void ResetRecursive()
		{
			Reset();
			styleAsset.Reset();
		}

		public static UBImGuiSettings CreateTemporary()
		{
			UBImGuiSettings uBImGuiSettings = ScriptableObject.CreateInstance<UBImGuiSettings>();
			uBImGuiSettings.Reset();
			uBImGuiSettings.IsTemp = true;
			uBImGuiSettings.styleAsset = ImGuiStyleAsset.Default();
			return uBImGuiSettings;
		}
	}
	internal class UBImGuiSettingsPersistent : ScriptableObject
	{
		public UBImGuiSettings settings;

		private const string SettingsPath = "Packages/com.mastersix.ubimgui/Resources/Settings/";

		private const string SettingsPersistentAssetName = "UBImGui Settings Persister.asset";

		private const string SettingsAssetName = "DEFAULT Settings.asset";

		private const string StyleAssetName = "DEFAULT Style.asset";

		internal static UBImGuiSettings GetSettings()
		{
			UBImGuiSettingsPersistent uBImGuiSettingsPersistent = Plugin.resourcesBundle.LoadAsset<UBImGuiSettingsPersistent>("Settings/UBImGui Settings Persister");
			if (Object.op_Implicit((Object)(object)uBImGuiSettingsPersistent))
			{
				return uBImGuiSettingsPersistent.settings;
			}
			return UBImGuiSettings.CreateTemporary();
		}
	}
	public readonly struct CommandBufferWrapper
	{
		private readonly CommandBuffer _cmd;

		private readonly RasterCommandBuffer _rasterCmd;

		private readonly bool _isRaster;

		public CommandBufferWrapper(CommandBuffer cmd)
		{
			_cmd = cmd;
			_rasterCmd = null;
			_isRaster = false;
		}

		public CommandBufferWrapper(RasterCommandBuffer rasterCmd)
		{
			_cmd = null;
			_rasterCmd = rasterCmd;
			_isRaster = true;
		}

		public void SetViewport(Rect viewport)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (_isRaster)
			{
				_rasterCmd.SetViewport(viewport);
			}
			else
			{
				_cmd.SetViewport(viewport);
			}
		}

		public void SetViewProjectionMatrices(Matrix4x4 view, Matrix4x4 projection)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if (_isRaster)
			{
				_rasterCmd.SetViewProjectionMatrices(view, projection);
			}
			else
			{
				_cmd.SetViewProjectionMatrices(view, projection);
			}
		}

		public void EnableScissorRect(Rect viewport)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (_isRaster)
			{
				_rasterCmd.EnableScissorRect(viewport);
			}
			else
			{
				_cmd.EnableScissorRect(viewport);
			}
		}

		public void DisableScissorRect()
		{
			if (_isRaster)
			{
				_rasterCmd.DisableScissorRect();
			}
			else
			{
				_cmd.DisableScissorRect();
			}
		}

		public void DrawProceduralIndirect(GraphicsBuffer indexBuffer, Matrix4x4 matrix, Material material, int shaderPass, MeshTopology topology, GraphicsBuffer bufferWithArgs, int argsOffset, MaterialPropertyBlock properties)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (_isRaster)
			{
				_rasterCmd.DrawProceduralIndirect(indexBuffer, matrix, material, shaderPass, topology, bufferWithArgs, argsOffset, properties);
			}
			else
			{
				_cmd.DrawProceduralIndirect(indexBuffer, matrix, material, shaderPass, topology, bufferWithArgs, argsOffset, properties);
			}
		}

		public void DrawMesh(Mesh mesh, Matrix4x4 matrix, Material material, int submeshIndex, int shaderPass, MaterialPropertyBlock properties)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if (_isRaster)
			{
				_rasterCmd.DrawMesh(mesh, matrix, material, submeshIndex, shaderPass, properties);
			}
			else
			{
				_cmd.DrawMesh(mesh, matrix, material, submeshIndex, shaderPass, properties);
			}
		}
	}
	[Serializable]
	public struct DearImGuiIOConfig
	{
		public bool KeyboardNavigation;

		public bool GamepadNavigation;

		[Tooltip("Instruct navigation to move the move the mouse cursor.")]
		public bool NavSetMousePos;

		[Tooltip("Instruct navigation to not set the io.WantCaptureKeyboard when io.NavActive is set.")]
		public bool NavNoCaptureKeyboard;

		[Tooltip("Time for a double-click, in seconds.")]
		public float DoubleClickTime;

		[Tooltip("Distance threshold to stay in to validate a double-click, in pixels.")]
		public float DoubleClickMaxDist;

		[Tooltip("Distance threshold before considering we are dragging.")]
		public float DragThreshold;

		[Tooltip("When holding a key/button, time before it starts repeating, in seconds.")]
		public float KeyRepeatDelay;

		[Tooltip("When holding a key/button, rate at which it repeats, in seconds.")]
		public float KeyRepeatRate;

		[Tooltip("Global scale all fonts.")]
		public float FontGlobalScale;

		[Tooltip("Allow user scaling text of individual window with CTRL+Wheel.")]
		public bool FontAllowUserScaling;

		[Tooltip("Set to false to disable blinking cursor.")]
		public bool TextCursorBlink;

		[Tooltip("Enable resizing from the edges and from the lower-left corner.")]
		public bool ResizeFromEdges;

		[Tooltip("Set to true to only allow moving windows when clicked+dragged from the title bar. Windows without a title bar are not affected.")]
		public bool MoveFromTitleOnly;

		[Tooltip("Compact window memory usage when unused. Set to -1.0f to disable.")]
		public float MemoryCompactTimer;

		[Tooltip("Time between saving positions in .ini file, in seconds.")]
		public float IniSavingRate;

		[Tooltip("Enable docking support.")]
		public bool DockingEnable;

		public bool DockingNoSplit;

		[Tooltip("Show docking indicators when dragging a window, only if SHIFT is pressed.")]
		public bool DockingWithShift;

		[Tooltip("Always show the docking tab even with only one window")]
		public bool DockingAlwaysTabBar;

		public bool DockingTransparentPayload;

		public bool InputTextEnterKeepActive;

		public void ApplyTo(ImGuiIOPtr io)
		{
			io.ConfigFlags = (KeyboardNavigation ? (io.ConfigFlags | ImGuiConfigFlags.NavEnableKeyboard) : (io.ConfigFlags & ~ImGuiConfigFlags.NavEnableKeyboard));
			io.ConfigFlags = (GamepadNavigation ? (io.ConfigFlags | ImGuiConfigFlags.NavEnableGamepad) : (io.ConfigFlags & ~ImGuiConfigFlags.NavEnableGamepad));
			io.ConfigFlags = (NavSetMousePos ? (io.ConfigFlags | ImGuiConfigFlags.NavEnableSetMousePos) : (io.ConfigFlags & ~ImGuiConfigFlags.NavEnableSetMousePos));
			io.ConfigFlags = (NavNoCaptureKeyboard ? (io.ConfigFlags | ImGuiConfigFlags.NavNoCaptureKeyboard) : (io.ConfigFlags & ~ImGuiConfigFlags.NavNoCaptureKeyboard));
			io.MouseDoubleClickTime = DoubleClickTime;
			io.MouseDoubleClickMaxDist = DoubleClickMaxDist;
			io.MouseDragThreshold = DragThreshold;
			io.KeyRepeatDelay = KeyRepeatDelay;
			io.KeyRepeatRate = KeyRepeatRate;
			io.FontGlobalScale = FontGlobalScale;
			io.FontAllowUserScaling = FontAllowUserScaling;
			io.ConfigInputTextCursorBlink = TextCursorBlink;
			io.ConfigWindowsResizeFromEdges = ResizeFromEdges;
			io.ConfigWindowsMoveFromTitleBarOnly = MoveFromTitleOnly;
			io.ConfigMemoryCompactTimer = MemoryCompactTimer;
			io.IniSavingRate = IniSavingRate;
			io.ConfigFlags = (DockingEnable ? (io.ConfigFlags | ImGuiConfigFlags.DockingEnable) : (io.ConfigFlags & ~ImGuiConfigFlags.DockingEnable));
			io.ConfigDockingNoSplit = DockingNoSplit;
			io.ConfigDockingWithShift = DockingWithShift;
			io.ConfigDockingAlwaysTabBar = DockingAlwaysTabBar;
			io.ConfigDockingTransparentPayload = DockingTransparentPayload;
			io.ConfigInputTextEnterKeepActive = InputTextEnterKeepActive;
		}

		public void CopyFrom(ImGuiIOPtr io)
		{
			KeyboardNavigation = (io.ConfigFlags & ImGuiConfigFlags.NavEnableKeyboard) != 0;
			GamepadNavigation = (io.ConfigFlags & ImGuiConfigFlags.NavEnableGamepad) != 0;
			NavSetMousePos = (io.ConfigFlags & ImGuiConfigFlags.NavEnableSetMousePos) != 0;
			NavNoCaptureKeyboard = (io.ConfigFlags & ImGuiConfigFlags.NavNoCaptureKeyboard) != 0;
			DoubleClickTime = io.MouseDoubleClickTime;
			DoubleClickMaxDist = io.MouseDoubleClickMaxDist;
			DragThreshold = io.MouseDragThreshold;
			KeyRepeatDelay = io.KeyRepeatDelay;
			KeyRepeatRate = io.KeyRepeatRate;
			FontGlobalScale = io.FontGlobalScale;
			FontAllowUserScaling = io.FontAllowUserScaling;
			TextCursorBlink = io.ConfigInputTextCursorBlink;
			ResizeFromEdges = io.ConfigWindowsResizeFromEdges;
			MoveFromTitleOnly = io.ConfigWindowsMoveFromTitleBarOnly;
			MemoryCompactTimer = io.ConfigMemoryCompactTimer;
			IniSavingRate = io.IniSavingRate;
			DockingEnable = (io.ConfigFlags & ImGuiConfigFlags.DockingEnable) != 0;
			DockingNoSplit = io.ConfigDockingNoSplit;
			DockingWithShift = io.ConfigDockingWithShift;
			DockingAlwaysTabBar = io.ConfigDockingAlwaysTabBar;
			DockingTransparentPayload = io.ConfigDockingTransparentPayload;
			InputTextEnterKeepActive = io.ConfigInputTextEnterKeepActive;
		}

		public void Reset()
		{
			IntPtr currentContext = ImGui.GetCurrentContext();
			IntPtr intPtr = ImGui.CreateContext();
			ImGui.SetCurrentContext(intPtr);
			CopyFrom(ImGui.GetIO());
			if (currentContext != IntPtr.Zero)
			{
				ImGui.SetCurrentContext(currentContext);
			}
			ImGui.DestroyContext(intPtr);
		}
	}
	[Serializable]
	public struct FontSettings
	{
		[Flags]
		public enum ScriptGlyphRanges
		{
			Default = 1,
			Cyrillic = 2,
			Japanese = 4,
			Korean = 8,
			Thai = 0x10,
			Vietnamese = 0x20,
			ChineseSimplified = 0x40,
			ChineseFull = 0x80,
			Custom = 0x100
		}

		[Serializable]
		public struct Range
		{
			public ushort start;

			public ushort end;
		}

		public Object fontObject;

		[HideInInspector]
		public string fontPath;

		public int sizeInPixels;

		public ScriptGlyphRanges glyphRanges;

		public Range[] customGlyphRanges;

		public unsafe List<ushort> BuildRanges()
		{
			ImFontAtlas* self = null;
			List<ushort> ranges = new List<ushort>();
			if ((glyphRanges & ScriptGlyphRanges.Default) != 0)
			{
				AddRangePtr(ImGuiNative.ImFontAtlas_GetGlyphRangesDefault(self));
			}
			if ((glyphRanges & ScriptGlyphRanges.Cyrillic) != 0)
			{
				AddRangePtr(ImGuiNative.ImFontAtlas_GetGlyphRangesCyrillic(self));
			}
			if ((glyphRanges & ScriptGlyphRanges.Japanese) != 0)
			{
				AddRangePtr(ImGuiNative.ImFontAtlas_GetGlyphRangesJapanese(self));
			}
			if ((glyphRanges & ScriptGlyphRanges.Korean) != 0)
			{
				AddRangePtr(ImGuiNative.ImFontAtlas_GetGlyphRangesKorean(self));
			}
			if ((glyphRanges & ScriptGlyphRanges.Thai) != 0)
			{
				AddRangePtr(ImGuiNative.ImFontAtlas_GetGlyphRangesThai(self));
			}
			if ((glyphRanges & ScriptGlyphRanges.Vietnamese) != 0)
			{
				AddRangePtr(ImGuiNative.ImFontAtlas_GetGlyphRangesVietnamese(self));
			}
			if ((glyphRanges & ScriptGlyphRanges.ChineseSimplified) != 0)
			{
				AddRangePtr(ImGuiNative.ImFontAtlas_GetGlyphRangesChineseSimplifiedCommon(self));
			}
			if ((glyphRanges & ScriptGlyphRanges.ChineseFull) != 0)
			{
				AddRangePtr(ImGuiNative.ImFontAtlas_GetGlyphRangesChineseFull(self));
			}
			if ((glyphRanges & ScriptGlyphRanges.Custom) != 0)
			{
				Range[] array = customGlyphRanges;
				for (int i = 0; i < array.Length; i++)
				{
					Range range = array[i];
					ranges.AddRange(new ushort[2] { range.start, range.end });
				}
			}
			return ranges;
			unsafe void AddRangePtr(ushort* r)
			{
				while (*r != 0)
				{
					ranges.Add(*(r++));
				}
			}
		}
	}
	public class ImGuiTextures : IDisposable
	{
		private Texture2D _atlasTexture;

		private readonly TwoWayDictionary<int, Texture> _textures = new TwoWayDictionary<int, Texture>();

		private int _currentTextureId;

		private readonly HashSet<IntPtr> _allocatedGlyphRangeArrays = new HashSet<IntPtr>(IntPtrEqualityComparer.Instance);

		public void UpdateTextures(ImGuiIOPtr io)
		{
			_currentTextureId = 0;
			_textures.Clear();
			io.Fonts.SetTexID((IntPtr)Bind((Texture)(object)_atlasTexture));
		}

		private int Bind(Texture texture)
		{
			_textures[++_currentTextureId] = texture;
			return _currentTextureId;
		}

		public Texture GetTexture(int id)
		{
			return _textures.Contains(id) ? _textures[id] : null;
		}

		public int GetTextureId(Texture texture)
		{
			return _textures.Contains(texture) ? _textures[texture] : (-1);
		}

		public IntPtr GetTexturePtr(Texture texture)
		{
			return (IntPtr)GetTextureId(texture);
		}

		public IntPtr GetTexturePtr(int id)
		{
			return _textures.Contains(id) ? ((IntPtr)id) : IntPtr.Zero;
		}

		public IntPtr GetOrCreate(Texture texture)
		{
			int num = GetTextureId(texture);
			if (num == -1)
			{
				num = Bind(texture);
			}
			return (IntPtr)num;
		}

		private unsafe IntPtr AllocateGlyphRangeArray(in FontSettings fontSettings)
		{
			List<ushort> list = fontSettings.BuildRanges();
			if (list.Count == 0)
			{
				return IntPtr.Zero;
			}
			int byteCount = 2 * (list.Count + 1);
			ushort* ptr = (ushort*)Util.Allocate(byteCount);
			_allocatedGlyphRangeArrays.Add((IntPtr)ptr);
			for (int i = 0; i < list.Count; i++)
			{
				ptr[i] = list[i];
			}
			ptr[list.Count] = 0;
			return (IntPtr)ptr;
		}

		private unsafe void FreeGlyphRangeArrays()
		{
			foreach (IntPtr allocatedGlyphRangeArray in _allocatedGlyphRangeArrays)
			{
				Util.Free((byte*)(void*)allocatedGlyphRangeArray);
			}
			_allocatedGlyphRangeArrays.Clear();
		}

		public void BuildFontAtlas(ImGuiIOPtr io, in ImGuiFontAsset fontAsset = null)
		{
			ImFontAtlasPtr fonts = io.Fonts;
			if (fonts.IsBuilt())
			{
				DestroyFontAtlas(io);
			}
			if (!io.MouseDrawCursor)
			{
				fonts = io.Fonts;
				fonts.Flags |= ImFontAtlasFlags.NoMouseCursors;
			}
			if (Object.op_Implicit((Object)(object)fontAsset) && fontAsset.fontSettings.Length != 0)
			{
				FontSettings[] fontSettings = fontAsset.fontSettings;
				for (int i = 0; i < fontSettings.Length; i++)
				{
					FontSettings fontSettings2 = fontSettings[i];
					string text = Path.Combine(Application.streamingAssetsPath, fontSettings2.fontPath);
					if (!File.Exists(text))
					{
						Debug.LogError((object)("Font file not found: " + text));
						continue;
					}
					fonts = io.Fonts;
					fonts.AddFontFromFileTTF(text, fontSettings2.sizeInPixels, null, AllocateGlyphRangeArray(in fontSettings2));
				}
			}
			fonts = io.Fonts;
			fonts.AddFontDefault();
			fonts = io.Fonts;
			fonts.Build();
		}

		public unsafe void BuildAtlasTexture(ImGuiIOPtr io)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			io.Fonts.GetTexDataAsRGBA32(out byte* out_pixels, out int out_width, out int out_height, out int out_bytes_per_pixel);
			_atlasTexture = new Texture2D(out_width, out_height, (TextureFormat)4, false, false)
			{
				filterMode = (FilterMode)0
			};
			NativeArray<byte> val = NativeArrayUnsafeUtility.ConvertExistingDataToNativeArray<byte>((void*)out_pixels, out_width * out_height * out_bytes_per_pixel, (Allocator)1);
			NativeArray<byte> rawTextureData = _atlasTexture.GetRawTextureData<byte>();
			int num = out_width * out_bytes_per_pixel;
			for (int i = 0; i < out_height; i++)
			{
				NativeArray<byte>.Copy(val, i * num, rawTextureData, (out_height - i - 1) * num, num);
			}
			_atlasTexture.Apply();
		}

		public unsafe void DestroyFontAtlas(ImGuiIOPtr io)
		{
			FreeGlyphRangeArrays();
			io.Fonts.Clear();
			io.NativePtr->FontDefault = default(ImFont*);
		}

		public void Dispose()
		{
			_currentTextureId = 0;
			_textures.Clear();
			if (Object.op_Implicit((Object)(object)_atlasTexture))
			{
				Object.Destroy((Object)(object)_atlasTexture);
				_atlasTexture = null;
			}
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate string GetClipboardTextCallback(void* userData);
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public unsafe delegate void SetClipboardTextCallback(void* userData, byte* text);
	public class ClipboardHandler : IDisposable
	{
		private static GetClipboardTextCallback _getClipboardText;

		private static SetClipboardTextCallback _setClipboardText;

		public unsafe ClipboardHandler()
		{
			_getClipboardText = GetClipboardTextCallback;
			_setClipboardText = SetClipboardTextCallback;
		}

		[MonoPInvokeCallback(typeof(GetClipboardTextCallback))]
		private unsafe static string GetClipboardTextCallback(void* userData)
		{
			return GUIUtility.systemCopyBuffer;
		}

		[MonoPInvokeCallback(typeof(SetClipboardTextCallback))]
		private unsafe static void SetClipboardTextCallback(void* userData, byte* text)
		{
			GUIUtility.systemCopyBuffer = StringFromPtr(text);
		}

		public void Assign(ImGuiIOPtr io)
		{
			io.ClipboardUserData = IntPtr.Zero;
			io.SetClipboardTextFn = Marshal.GetFunctionPointerForDelegate(_setClipboardText);
			io.GetClipboardTextFn = Marshal.GetFunctionPointerForDelegate(_getClipboardText);
		}

		public void Unset(ImGuiIOPtr io)
		{
			io.SetClipboardTextFn = IntPtr.Zero;
			io.GetClipboardTextFn = IntPtr.Zero;
		}

		public void Dispose()
		{
			_getClipboardText = null;
			_setClipboardText = null;
		}

		private unsafe static string StringFromPtr(byte* ptr)
		{
			int i;
			for (i = 0; ptr[i] != 0; i++)
			{
			}
			return Encoding.UTF8.GetString(ptr, i);
		}
	}
	public interface IInputHandler : IDisposable
	{
		Vector2 MouseOffset { get; set; }

		void Initialize(ImGuiIOPtr io);

		void Update(ImGuiIOPtr io);

		void IDisposable.Dispose()
		{
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static Vector2 ScreenToImGui(in Vector2 point)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(point.x, ImGui.GetIO().DisplaySize.y - point.y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static Vector2 ImGuiToScreen(in Vector2 point)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(point.x, ImGui.GetIO().DisplaySize.y - point.y);
		}
	}
	public class InputManagerHandler : IInputHandler, IDisposable
	{
		private readonly Event _charEvent = new Event();

		private ImGuiMouseCursor _lastCursor = ImGuiMouseCursor.None;

		private readonly ImGuiCursorAsset _cursorAsset;

		public Vector2 MouseOffset { get; set; } = Vector2.zero;


		public InputManagerHandler(ImGuiCursorAsset cursorAsset = null)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			_cursorAsset = cursorAsset;
		}

		public void Initialize(ImGuiIOPtr io)
		{
			io.SetBackendPlatformName("Unity Input Manager");
			io.BackendFlags |= ImGuiBackendFlags.HasSetMousePos;
			io.BackendFlags = (Object.op_Implicit((Object)(object)_cursorAsset) ? (io.BackendFlags | ImGuiBackendFlags.HasMouseCursors) : (io.BackendFlags & ~ImGuiBackendFlags.HasMouseCursors));
		}

		public void Update(ImGuiIOPtr io)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Invalid comparison between Unknown and I4
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			bool flag = (Object)(object)EventSystem.current != (Object)null && (Object)(object)EventSystem.current.currentSelectedGameObject != (Object)null && (Object)(object)EventSystem.current.currentSelectedGameObject.GetComponent<InputField>() != (Object)null;
			while (!flag && Event.PopEvent(_charEvent))
			{
				if ((int)_charEvent.rawType == 4 && _charEvent.character != 0 && _charEvent.character != '\n')
				{
					io.AddInputCharacter(_charEvent.character);
				}
			}
			foreach (KeyCode value in Enum.GetValues(typeof(KeyCode)))
			{
				if (KeyCodeToImGuiKey(value, out var key))
				{
					io.AddKeyEvent(key, Input.GetKey(value));
				}
			}
			Vector2 point;
			if (io.WantSetMousePos)
			{
				point = new Vector2(io.MousePos.x, io.MousePos.y);
				Input.compositionCursorPos = IInputHandler.ImGuiToScreen(in point);
				io.WantSetMousePos = false;
			}
			point = new Vector2(Input.mousePosition.x, Input.mousePosition.y);
			Vector2 val2 = IInputHandler.ScreenToImGui(in point);
			io.AddMousePosEvent(val2.x, val2.y);
			io.AddMouseButtonEvent(0, Input.GetMouseButton(0));
			io.AddMouseButtonEvent(1, Input.GetMouseButton(1));
			io.AddMouseButtonEvent(2, Input.GetMouseButton(2));
			io.AddMouseWheelEvent(Input.mouseScrollDelta.x, Input.mouseScrollDelta.y);
			if (Object.op_Implicit((Object)(object)_cursorAsset))
			{
				UpdateCursor(io, ImGui.GetMouseCursor());
			}
		}

		private void UpdateCursor(ImGuiIOPtr io, ImGuiMouseCursor cursor)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			if (io.MouseDrawCursor)
			{
				cursor = ImGuiMouseCursor.None;
			}
			if (_lastCursor != cursor && (io.ConfigFlags & ImGuiConfigFlags.NoMouseCursorChange) == 0)
			{
				_lastCursor = cursor;
				Cursor.visible = cursor != ImGuiMouseCursor.None;
				Cursor.SetCursor(_cursorAsset[cursor].texture, _cursorAsset[cursor].hotspot, (CursorMode)0);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private bool KeyCodeToImGuiKey(KeyCode keyCode, out ImGuiKey key)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Invalid comparison between Unknown and I4
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Invalid comparison between Unknown and I4
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Invalid comparison between Unknown and I4
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Expected I4, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Invalid comparison between Unknown and I4
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Invalid comparison between Unknown and I4
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Invalid comparison between Unknown and I4
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Invalid comparison between Unknown and I4
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Invalid comparison between Unknown and I4
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Invalid comparison between Unknown and I4
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Invalid comparison between Unknown and I4
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Invalid comparison between Unknown and I4
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Invalid comparison between Unknown and I4
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Invalid comparison between Unknown and I4
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Invalid comparison between Unknown and I4
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: Expected I4, but got Unknown
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Invalid comparison between Unknown and I4
			//IL_0295: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Invalid comparison between Unknown and I4
			//IL_0289: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Expected I4, but got Unknown
			//IL_029e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Invalid comparison between Unknown and I4
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected I4, but got Unknown
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Expected I4, but got Unknown
			//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0301: Invalid comparison between Unknown and I4
			//IL_0303: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: Invalid comparison between Unknown and I4
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Invalid comparison between Unknown and I4
			//IL_0316: Unknown result type (might be due to invalid IL or missing references)
			//IL_031d: Unknown result type (might be due to invalid IL or missing references)
			//IL_031e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0321: Expected I4, but got Unknown
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Invalid comparison between Unknown and I4
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Expected I4, but got Unknown
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Expected I4, but got Unknown
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Invalid comparison between Unknown and I4
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Expected I4, but got Unknown
			if ((int)keyCode == 0)
			{
				key = ImGuiKey.None;
				return true;
			}
			if (1 == 0)
			{
			}
			ImGuiKey imGuiKey;
			if ((int)keyCode <= 27)
			{
				if ((int)keyCode <= 9)
				{
					if ((int)keyCode != 8)
					{
						if ((int)keyCode != 9)
						{
							goto IL_0250;
						}
						imGuiKey = ImGuiKey.Tab;
					}
					else
					{
						imGuiKey = ImGuiKey.Backspace;
					}
				}
				else if ((int)keyCode != 13)
				{
					if ((int)keyCode != 27)
					{
						goto IL_0250;
					}
					imGuiKey = ImGuiKey.Escape;
				}
				else
				{
					imGuiKey = ImGuiKey.Enter;
				}
			}
			else if ((int)keyCode <= 127)
			{
				if ((int)keyCode != 32)
				{
					if ((int)keyCode != 127)
					{
						goto IL_0250;
					}
					imGuiKey = ImGuiKey.Delete;
				}
				else
				{
					imGuiKey = ImGuiKey.Space;
				}
			}
			else
			{
				switch (keyCode - 273)
				{
				case 7:
					goto IL_01cc;
				case 8:
					goto IL_01d8;
				case 6:
					goto IL_01e4;
				case 5:
					goto IL_01f0;
				case 3:
					goto IL_01fc;
				case 2:
					goto IL_0208;
				case 0:
					goto IL_0214;
				case 1:
					goto IL_0220;
				case 4:
					goto IL_0238;
				}
				if ((int)keyCode != 301)
				{
					if ((int)keyCode != 316)
					{
						goto IL_0250;
					}
					imGuiKey = ImGuiKey.PrintScreen;
				}
				else
				{
					imGuiKey = ImGuiKey.CapsLock;
				}
			}
			goto IL_03c1;
			IL_01d8:
			imGuiKey = ImGuiKey.PageDown;
			goto IL_03c1;
			IL_01fc:
			imGuiKey = ImGuiKey.LeftArrow;
			goto IL_03c1;
			IL_0238:
			imGuiKey = ImGuiKey.Insert;
			goto IL_03c1;
			IL_03c1:
			if (1 == 0)
			{
			}
			key = imGuiKey;
			return key != ImGuiKey.None;
			IL_01cc:
			imGuiKey = ImGuiKey.PageUp;
			goto IL_03c1;
			IL_01e4:
			imGuiKey = ImGuiKey.End;
			goto IL_03c1;
			IL_0250:
			if ((int)keyCode >= 256 && (int)keyCode <= 265)
			{
				imGuiKey = (ImGuiKey)(536 + (keyCode - 256));
			}
			else if ((int)keyCode >= 97 && (int)keyCode <= 122)
			{
				imGuiKey = (ImGuiKey)(546 + (keyCode - 97));
			}
			else if ((int)keyCode < 48 || (int)keyCode > 57)
			{
				switch (keyCode - 266)
				{
				case 2:
					imGuiKey = ImGuiKey.KeypadMultiply;
					break;
				case 4:
					imGuiKey = ImGuiKey.KeypadAdd;
					break;
				case 3:
					imGuiKey = ImGuiKey.KeypadSubtract;
					break;
				case 0:
					imGuiKey = ImGuiKey.KeypadDecimal;
					break;
				case 1:
					imGuiKey = ImGuiKey.KeypadDivide;
					break;
				default:
					{
						if ((int)keyCode < 282 || (int)keyCode > 296)
						{
							if ((int)keyCode <= 59)
							{
								switch (keyCode - 39)
								{
								case 5:
									goto IL_036b;
								case 6:
									goto IL_0374;
								case 7:
									goto IL_037d;
								case 8:
									goto IL_0386;
								case 0:
									goto IL_03b3;
								case 1:
								case 2:
								case 3:
								case 4:
									goto IL_03bc;
								}
								if ((int)keyCode != 59)
								{
									goto IL_03bc;
								}
								imGuiKey = ImGuiKey.Semicolon;
								break;
							}
							if ((int)keyCode != 61)
							{
								switch (keyCode - 91)
								{
								case 5:
									goto IL_038f;
								case 0:
									goto IL_0398;
								case 2:
									goto IL_03a1;
								case 1:
									goto IL_03aa;
								case 3:
								case 4:
									goto IL_03bc;
								}
								switch (keyCode - 300)
								{
								case 0:
									break;
								case 2:
									goto IL_0332;
								case 4:
									goto IL_033e;
								case 6:
									goto IL_0347;
								case 8:
									goto IL_0350;
								default:
									goto IL_03bc;
								}
								imGuiKey = ImGuiKey.NumLock;
							}
							else
							{
								imGuiKey = ImGuiKey.Equal;
							}
							break;
						}
						imGuiKey = (ImGuiKey)(572 + (keyCode - 282));
						break;
					}
					IL_0347:
					imGuiKey = ImGuiKey.ModCtrl;
					break;
					IL_033e:
					imGuiKey = ImGuiKey.ModShift;
					break;
					IL_0350:
					imGuiKey = ImGuiKey.ModAlt;
					break;
					IL_0332:
					imGuiKey = ImGuiKey.ScrollLock;
					break;
					IL_03b3:
					imGuiKey = ImGuiKey.Apostrophe;
					break;
					IL_0386:
					imGuiKey = ImGuiKey.Slash;
					break;
					IL_037d:
					imGuiKey = ImGuiKey.Period;
					break;
					IL_0374:
					imGuiKey = ImGuiKey.Minus;
					break;
					IL_036b:
					imGuiKey = ImGuiKey.Comma;
					break;
					IL_03aa:
					imGuiKey = ImGuiKey.Backslash;
					break;
					IL_03a1:
					imGuiKey = ImGuiKey.RightBracket;
					break;
					IL_0398:
					imGuiKey = ImGuiKey.LeftBracket;
					break;
					IL_038f:
					imGuiKey = ImGuiKey.GraveAccent;
					break;
					IL_03bc:
					imGuiKey = ImGuiKey.None;
					break;
				}
			}
			else
			{
				imGuiKey = (ImGuiKey)(612 + (keyCode - 48));
			}
			goto IL_03c1;
			IL_0214:
			imGuiKey = ImGuiKey.UpArrow;
			goto IL_03c1;
			IL_01f0:
			imGuiKey = ImGuiKey.Home;
			goto IL_03c1;
			IL_0208:
			imGuiKey = ImGuiKey.RightArrow;
			goto IL_03c1;
			IL_0220:
			imGuiKey = ImGuiKey.DownArrow;
			goto IL_03c1;
		}
	}
	[DefaultExecutionOrder(1000)]
	public class ImGuiBehaviour : MonoBehaviour
	{
		private enum RenderPipelineOption
		{
			BuiltIn,
			Custom,
			URP,
			HDRP
		}

		[CompilerGenerated]
		private sealed class <RenderInFront>d__24 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ImGuiBehaviour <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <RenderInFront>d__24(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0094: Unknown result type (might be due to invalid IL or missing references)
				//IL_009e: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<>4__this._renderInFront)
				{
					if (!<>4__this._isEnabled)
					{
						return false;
					}
					<>4__this._cmd.Clear();
					ImGuiController controller = <>4__this._controller;
					CommandBufferWrapper cmd = new CommandBufferWrapper(<>4__this._cmd);
					controller.Render(in cmd, <>4__this._controller.CameraToRender);
					Graphics.ExecuteCommandBuffer(<>4__this._cmd);
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 1;
					return true;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private static ImGuiBehaviour _instance;

		private ImGuiController _controller;

		private CommandBuffer _cmd;

		private bool _isEnabled;

		private bool _renderInFront;

		private Camera _imguiCamera;

		private RenderPipelineOption _currentRenderPipeline = RenderPipelineOption.BuiltIn;

		private DearImGuiRenderPassFeature _renderPassFeature;

		public static bool IsRenderingInFront => _instance._renderInFront;

		public static void Initialize()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			if (!Object.op_Implicit((Object)(object)_instance))
			{
				if (!Application.isPlaying)
				{
					throw new Exception("ImGuiBehaviour can only be initialized while the application is playing.");
				}
				GameObject val = new GameObject("ImGuiBehaviour")
				{
					hideFlags = (HideFlags)11
				};
				_instance = val.AddComponent<ImGuiBehaviour>();
				Object.DontDestroyOnLoad((Object)(object)val);
			}
		}

		private void OnEnable()
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Expected O, but got Unknown
			if (!Object.op_Implicit((Object)(object)_instance))
			{
				_instance = this;
			}
			if ((Object)(object)_instance != (Object)(object)this)
			{
				Object.DestroyImmediate((Object)(object)((Component)this).gameObject);
				return;
			}
			_isEnabled = true;
			_cmd = new CommandBuffer
			{
				name = "Dear ImGui"
			};
			CreateImGuiCamera();
			_controller = new ImGuiController(_imguiCamera);
			_controller.MakeCurrent();
			_renderInFront = true;
			((Component)_imguiCamera).gameObject.SetActive(false);
			if (_renderInFront)
			{
				((MonoBehaviour)this).StartCoroutine(RenderInFront());
				return;
			}
			Camera.onPostRender = (CameraCallback)Delegate.Combine((Delegate?)(object)Camera.onPostRender, (Delegate?)new CameraCallback(PostRender));
			RenderPipelineManager.beginContextRendering += BeginContextRendering;
			RenderPipelineManager.beginCameraRendering += BeginCameraRendering;
			RenderPipelineManager.endCameraRendering += EndCameraRendering;
		}

		private void OnDisable()
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			if (!_isEnabled)
			{
				return;
			}
			_isEnabled = false;
			_instance = null;
			_cmd.Dispose();
			_controller.Dispose();
			if (!_renderInFront)
			{
				Camera.onPostRender = (CameraCallback)Delegate.Remove((Delegate?)(object)Camera.onPostRender, (Delegate?)new CameraCallback(PostRender));
				RenderPipelineManager.beginContextRendering -= BeginContextRendering;
				RenderPipelineManager.beginCameraRendering -= BeginCameraRendering;
				RenderPipelineManager.endCameraRendering -= EndCameraRendering;
				RemoveFromMainCameraStack();
				if ((Object)(object)_renderPassFeature != (Object)null)
				{
					Object.DestroyImmediate((Object)(object)_renderPassFeature);
					_renderPassFeature = null;
				}
			}
		}

		private void UpdateCurrentRenderPipeline()
		{
			Type type = ((RenderPipelineManager.currentPipeline != null) ? ((object)RenderPipelineManager.currentPipeline).GetType() : null);
			if (type == typeof(UniversalRenderPipeline))
			{
				_currentRenderPipeline = RenderPipelineOption.URP;
			}
			else
			{
				_currentRenderPipeline = ((type != null) ? RenderPipelineOption.Custom : RenderPipelineOption.BuiltIn);
			}
		}

		private void CreateImGuiCamera()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("ImGui Camera");
			val.transform.SetParent(((Component)this).transform);
			_imguiCamera = val.AddComponent<Camera>();
			_imguiCamera.clearFlags = (CameraClearFlags)4;
			_imguiCamera.cullingMask = 0;
			_imguiCamera.orthographic = true;
			_imguiCamera.orthographicSize = 1f;
			_imguiCamera.nearClipPlane = -1f;
			_imguiCamera.farClipPlane = 1f;
			_imguiCamera.rect = new Rect(0f, 0f, 1f, 1f);
			_imguiCamera.depth = 100f;
			UniversalAdditionalCameraData universalAdditionalCameraData = CameraExtensions.GetUniversalAdditionalCameraData(_imguiCamera);
			if (Object.op_Implicit((Object)(object)universalAdditionalCameraData))
			{
				universalAdditionalCameraData.renderPostProcessing = false;
				universalAdditionalCameraData.renderShadows = false;
				universalAdditionalCameraData.requiresColorOption = (CameraOverrideOption)0;
				universalAdditionalCameraData.requiresDepthOption = (CameraOverrideOption)0;
			}
		}

		private void AddToMainCameraStack()
		{
			Camera main = Camera.main;
			if (!Object.op_Implicit((Object)(object)main))
			{
				return;
			}
			UniversalAdditionalCameraData universalAdditionalCameraData = CameraExtensions.GetUniversalAdditionalCameraData(main);
			if (Object.op_Implicit((Object)(object)universalAdditionalCameraData))
			{
				List<Camera> cameraStack = universalAdditionalCameraData.cameraStack;
				if (!cameraStack.Contains(_imguiCamera))
				{
					cameraStack.Add(_imguiCamera);
				}
			}
		}

		private void RemoveFromMainCameraStack()
		{
			Camera main = Camera.main;
			if (!Object.op_Implicit((Object)(object)main))
			{
				return;
			}
			UniversalAdditionalCameraData universalAdditionalCameraData = CameraExtensions.GetUniversalAdditionalCameraData(main);
			if (Object.op_Implicit((Object)(object)universalAdditionalCameraData))
			{
				List<Camera> cameraStack = universalAdditionalCameraData.cameraStack;
				if (cameraStack.Contains(_imguiCamera))
				{
					cameraStack.Remove(_imguiCamera);
				}
			}
		}

		private void Update()
		{
			_controller.NewFrame();
		}

		private void PostRender(Camera camera)
		{
			_cmd.Clear();
			CommandBufferWrapper cmd = new CommandBufferWrapper(_cmd);
			Render(in cmd, camera);
			Graphics.ExecuteCommandBuffer(_cmd);
		}

		private void BeginContextRendering(ScriptableRenderContext context, List<Camera> cameras)
		{
			UpdateCurrentRenderPipeline();
		}

		private void BeginFrameRendering(ScriptableRenderContext context, Camera[] cameras)
		{
			UpdateCurrentRenderPipeline();
		}

		private void BeginCameraRendering(ScriptableRenderContext context, Camera camera)
		{
			if (_currentRenderPipeline != RenderPipelineOption.URP)
			{
				return;
			}
			UniversalAdditionalCameraData universalAdditionalCameraData = CameraExtensions.GetUniversalAdditionalCameraData(camera);
			if ((Object)(object)universalAdditionalCameraData != (Object)null)
			{
				ScriptableRenderer scriptableRenderer = universalAdditionalCameraData.scriptableRenderer;
				if ((Object)(object)_renderPassFeature == (Object)null)
				{
					_renderPassFeature = ScriptableObject.CreateInstance<DearImGuiRenderPassFeature>();
				}
				_renderPassFeature.AddRenderPasses(scriptableRenderer, camera);
			}
		}

		private void EndCameraRendering(ScriptableRenderContext context, Camera camera)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (_currentRenderPipeline == RenderPipelineOption.Custom)
			{
				ExecuteCustomRenderPass(context, camera);
			}
		}

		[IteratorStateMachine(typeof(<RenderInFront>d__24))]
		private IEnumerator RenderInFront()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RenderInFront>d__24(0)
			{
				<>4__this = this
			};
		}

		private void Render(in CommandBufferWrapper cmd, Camera camera)
		{
			if (!_renderInFront)
			{
				_controller.Render(in cmd, camera);
			}
		}

		internal static void ExecuteCustomRenderPass(ScriptableRenderContext context, Camera camera)
		{
			if (_instance._isEnabled)
			{
				_instance._cmd.Clear();
				ImGuiBehaviour instance = _instance;
				CommandBufferWrapper cmd = new CommandBufferWrapper(_instance._cmd);
				instance.Render(in cmd, camera);
				((ScriptableRenderContext)(ref context)).ExecuteCommandBuffer(_instance._cmd);
			}
		}

		internal static void ExecuteCustomRenderGraphPass(in CommandBufferWrapper cmd, Camera camera)
		{
			if (Object.op_Implicit((Object)(object)_instance) && _instance._isEnabled)
			{
				_instance.Render(in cmd, camera);
			}
		}
	}
	public class ImGuiController : IDisposable
	{
		private bool _frameBegun;

		private IInputHandler _inputHandler;

		private IImGuiRenderer _renderer;

		private readonly ImGuiTextures _textures;

		private readonly ClipboardHandler _clipboardHandler;

		private UBImGuiSettings _settings;

		private Camera _camera;

		private bool _initialized;

		public IInputHandler InputHandler => _inputHandler;

		public static ImGuiController CurrentController { get; private set; }

		public static bool HasController => CurrentController != null;

		public IntPtr Context { get; private set; }

		internal ImGuiTextures Textures => _textures;

		internal UBImGuiSettings Settings => _settings;

		internal Camera CameraToRender => _camera;

		internal event Action Layout;

		public ImGuiController(Camera camera)
		{
			_textures = new ImGuiTextures();
			_camera = camera;
			_clipboardHandler = new ClipboardHandler();
			Initialize();
		}

		private void Initialize()
		{
			Context = ImGui.CreateContext();
			ImGui.SetCurrentContext(Context);
			if (Context == IntPtr.Zero)
			{
				_initialized = false;
				return;
			}
			ImGuiIOPtr iO = ImGui.GetIO();
			_settings = UBImGuiSettingsPersistent.GetSettings();
			_settings.ApplyTo(ImGui.GetStyle(), iO);
			if (_settings.iniSettingsSize != 0)
			{
				ImGui.LoadIniSettingsFromMemory(_settings.iniSettings, _settings.iniSettingsSize);
			}
			UBImGuiSettings.InputMode inputMode = _settings.inputMode;
			if (1 == 0)
			{
			}
			InputManagerHandler inputHandler = new InputManagerHandler(_settings.cursorAsset);
			if (1 == 0)
			{
			}
			_inputHandler = inputHandler;
			_inputHandler.Initialize(iO);
			_textures.BuildFontAtlas(iO, in _settings.fontAsset);
			_textures.BuildAtlasTexture(iO);
			_renderer = new GraphicsBufferRenderer(iO, _textures);
			_clipboardHandler.Assign(iO);
			if (!_settings.IsTemp)
			{
				iO.SetIniFilename(null);
				ImGui.LoadIniSettingsFromMemory(_settings.iniSettings, _settings.iniSettingsSize);
			}
			ImGui.NewFrame();
			_frameBegun = true;
			_initialized = true;
		}

		public void NewFrame()
		{
			if (_initialized)
			{
				ImGuiIOPtr iO = ImGui.GetIO();
				if (_frameBegun)
				{
					ImGui.Render();
				}
				SetPerFrameImGuiData();
				_inputHandler.Update(iO);
				_textures.UpdateTextures(iO);
				_frameBegun = true;
				ImGui.NewFrame();
				this.Layout?.Invoke();
			}
		}

		private void SetPerFrameImGuiData()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			ImGuiIOPtr iO = ImGui.GetIO();
			ref Vector2 displaySize = ref iO.DisplaySize;
			Rect pixelRect = _camera.pixelRect;
			float width = ((Rect)(ref pixelRect)).width;
			pixelRect = _camera.pixelRect;
			displaySize = new Vector2(width, ((Rect)(ref pixelRect)).height);
			iO.DeltaTime = Time.unscaledDeltaTime;
			if (iO.WantSaveIniSettings && !_settings.IsTemp)
			{
				_settings.iniSettings = ImGui.SaveIniSettingsToMemory(out var out_ini_size);
				_settings.iniSettingsSize = out_ini_size;
				iO.WantSaveIniSettings = false;
			}
		}

		public void Render(in CommandBufferWrapper cmd, Camera camera)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			if (_initialized && !((Object)(object)_camera != (Object)(object)camera) && _frameBegun)
			{
				_frameBegun = false;
				ImGui.Render();
				ImDrawDataPtr drawData = ImGui.GetDrawData();
				Vector2 val = drawData.DisplaySize * drawData.FramebufferScale;
				if (!(val.x <= 0f) && !(val.y <= 0f))
				{
					_renderer.UpdateBuffers(drawData);
					_renderer.Render(in cmd, drawData, val);
				}
			}
		}

		public void MakeCurrent()
		{
			if (_initialized)
			{
				CurrentController = this;
				ImGui.SetCurrentContext(Context);
			}
		}

		public void Dispose()
		{
			ImGuiIOPtr iO = ImGui.GetIO();
			_inputHandler.Dispose();
			_textures.Dispose();
			_renderer.Dispose();
			_clipboardHandler.Unset(iO);
			_clipboardHandler.Dispose();
			this.Layout = null;
			ImGui.DestroyContext(Context);
			Context = IntPtr.Zero;
			CurrentController = null;
		}
	}
	public class GraphicsBufferRenderer : IImGuiRenderer, IDisposable
	{
		private readonly Material _material = new Material(Plugin.resourcesBundle.LoadAsset<Shader>("DearImGui"));

		private readonly MaterialPropertyBlock _properties = new MaterialPropertyBlock();

		private readonly ImGuiTextures _textures;

		private static readonly int VertexProperty = Shader.PropertyToID("_Vertices");

		private static readonly int TextureProperty = Shader.PropertyToID("_Texture");

		private static readonly int BaseVertexProperty = Shader.PropertyToID("_BaseVertex");

		private GraphicsBuffer _vertexBuffer;

		private GraphicsBuffer _indexBuffer;

		private GraphicsBuffer _argsBuffer;

		private int[] _drawArgs = new int[5] { 0, 1, 0, 0, 0 };

		internal GraphicsBufferRenderer(ImGuiIOPtr io, ImGuiTextures textures)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			_textures = textures;
			io.BackendFlags |= ImGuiBackendFlags.RendererHasVtxOffset;
			io.SetBackendRendererName("Unity GraphicsBuffer Procedural Renderer");
		}

		public unsafe void UpdateBuffers(ImDrawDataPtr drawData)
		{
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			int i = 0;
			for (int cmdListsCount = drawData.CmdListsCount; i < cmdListsCount; i++)
			{
				num += drawData.CmdLists[i].CmdBuffer.Size;
			}
			EnsureCapacity<ImDrawVert>(ref _vertexBuffer, (Target)16, drawData.TotalVtxCount);
			EnsureCapacity<ushort>(ref _indexBuffer, (Target)2, drawData.TotalIdxCount);
			EnsureCapacity<int>(ref _argsBuffer, (Target)256, num * 5);
			int num2 = 0;
			int num3 = 0;
			int num4 = 0;
			int j = 0;
			for (int cmdListsCount2 = drawData.CmdListsCount; j < cmdListsCount2; j++)
			{
				ImDrawListPtr imDrawListPtr = drawData.CmdLists[j];
				NativeArray<ImDrawVert> val = NativeArrayUnsafeUtility.ConvertExistingDataToNativeArray<ImDrawVert>((void*)imDrawListPtr.VtxBuffer.Data, imDrawListPtr.VtxBuffer.Size, (Allocator)1);
				NativeArray<ushort> val2 = NativeArrayUnsafeUtility.ConvertExistingDataToNativeArray<ushort>((void*)imDrawListPtr.IdxBuffer.Data, imDrawListPtr.IdxBuffer.Size, (Allocator)1);
				_vertexBuffer.SetData<ImDrawVert>(val, 0, num2, val.Length);
				_indexBuffer.SetData<ushort>(val2, 0, num3, val2.Length);
				_drawArgs[3] = num2;
				int k = 0;
				for (int size = imDrawListPtr.CmdBuffer.Size; k < size; k++)
				{
					ImDrawCmdPtr imDrawCmdPtr = imDrawListPtr.CmdBuffer[k];
					_drawArgs[0] = (int)imDrawCmdPtr.ElemCount;
					_drawArgs[2] = num3 + (int)imDrawCmdPtr.IdxOffset;
					_argsBuffer.SetData((Array)_drawArgs, 0, num4, 5);
					num4 += 5;
				}
				num2 += val.Length;
				num3 += val2.Length;
			}
		}

		public void Render(in CommandBufferWrapper cmd, ImDrawDataPtr drawData, Vector2 frameBufferSize)
		{
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			IntPtr intPtr = IntPtr.Zero;
			Vector4 val = default(Vector4);
			((Vector4)(ref val))..ctor(drawData.DisplayPos.x, drawData.DisplayPos.y, drawData.DisplayPos.x, drawData.DisplayPos.y);
			Vector4 val2 = default(Vector4);
			((Vector4)(ref val2))..ctor(drawData.FramebufferScale.x, drawData.FramebufferScale.y, drawData.FramebufferScale.x, drawData.FramebufferScale.y);
			_material.SetBuffer(VertexProperty, _vertexBuffer);
			cmd.SetViewport(new Rect(0f, 0f, frameBufferSize.x, frameBufferSize.y));
			cmd.SetViewProjectionMatrices(Matrix4x4.Translate(new Vector3(0.5f / frameBufferSize.x, 0.5f / frameBufferSize.y, 0f)), Matrix4x4.Ortho(0f, frameBufferSize.x, frameBufferSize.y, 0f, 0f, 1f));
			int num = 0;
			int num2 = 0;
			int i = 0;
			Vector4 val3 = default(Vector4);
			for (int cmdListsCount = drawData.CmdListsCount; i < cmdListsCount; i++)
			{
				ImDrawListPtr imDrawListPtr = drawData.CmdLists[i];
				int num3 = 0;
				int size = imDrawListPtr.CmdBuffer.Size;
				while (num3 < size)
				{
					ImDrawCmdPtr imDrawCmdPtr = imDrawListPtr.CmdBuffer[num3];
					((Vector4)(ref val3))..ctor(imDrawCmdPtr.ClipRect.x, imDrawCmdPtr.ClipRect.y, imDrawCmdPtr.ClipRect.z, imDrawCmdPtr.ClipRect.w);
					Vector4 val4 = Vector4.Scale(val3 - val, val2);
					if (!(val4.x >= frameBufferSize.x) && !(val4.y >= frameBufferSize.y) && !(val4.z < 0f) && !(val4.w < 0f))
					{
						if (intPtr != imDrawCmdPtr.TextureId)
						{
							_properties.SetTexture(TextureProperty, _textures.GetTexture((int)(intPtr = imDrawCmdPtr.TextureId)));
						}
						_properties.SetInt(BaseVertexProperty, num + (int)imDrawCmdPtr.VtxOffset);
						cmd.EnableScissorRect(new Rect(val4.x, frameBufferSize.y - val4.w, val4.z - val4.x, val4.w - val4.y));
						cmd.DrawProceduralIndirect(_indexBuffer, Matrix4x4.identity, _material, -1, (MeshTopology)0, _argsBuffer, num2, _properties);
					}
					num3++;
					num2 += 20;
				}
				num += imDrawListPtr.VtxBuffer.Size;
			}
			cmd.DisableScissorRect();
		}

		private static void EnsureCapacity<T>(ref GraphicsBuffer buffer, Target target, int size) where T : struct
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			if (buffer == null || buffer.count <= size)
			{
				size = ((size - 1) / 256 + 1) * 256;
				GraphicsBuffer obj = buffer;
				if (obj != null)
				{
					obj.Release();
				}
				buffer = new GraphicsBuffer(target, size, UnsafeUtility.SizeOf<T>());
			}
		}

		public void Dispose()
		{
			if (Object.op_Implicit((Object)(object)_material))
			{
				Object.Destroy((Object)(object)_material);
			}
			GraphicsBuffer vertexBuffer = _vertexBuffer;
			if (vertexBuffer != null)
			{
				vertexBuffer.Release();
			}
			GraphicsBuffer indexBuffer = _indexBuffer;
			if (indexBuffer != null)
			{
				indexBuffer.Release();
			}
			GraphicsBuffer argsBuffer = _argsBuffer;
			if (argsBuffer != null)
			{
				argsBuffer.Release();
			}
		}

		void IImGuiRenderer.Render(in CommandBufferWrapper cmd, ImDrawDataPtr drawData, Vector2 frameBufferSize)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			Render(in cmd, drawData, frameBufferSize);
		}
	}
	public interface IImGuiRenderer : IDisposable
	{
		void UpdateBuffers(ImDrawDataPtr drawData);

		void Render(in CommandBufferWrapper cmd, ImDrawDataPtr drawData, Vector2 frameBufferSize);
	}
	public class DearImGuiRenderPassFeature : ScriptableRendererFeature
	{
		public class DearImGuiURPRenderPass : ScriptableRenderPass
		{
			private class PassData
			{
				public Camera camera;
			}

			[Obsolete]
			public override void Configure(CommandBuffer cmd, RenderTextureDescriptor cameraTextureDescriptor)
			{
			}

			[Obsolete]
			public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				ImGuiBehaviour.ExecuteCustomRenderPass(context, ((CameraData)(ref renderingData.cameraData)).camera);
			}

			public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)
			{
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				UniversalCameraData val = frameData.Get<UniversalCameraData>();
				UniversalResourceData val2 = frameData.Get<UniversalResourceData>();
				PassData passData = default(PassData);
				IRasterRenderGraphBuilder val3 = renderGraph.AddRasterRenderPass<PassData>("Dear Im Gui", ref passData, ((ScriptableRenderPass)this).profilingSampler, "C:\\Users\\liamp\\source\\repos\\PEAK\\UBImGui\\Runtime\\UBImGui\\Renderer\\URPRenderPass.cs", 39);
				try
				{
					val3.SetRenderAttachment(val2.activeColorTexture, 0, (AccessFlags)2);
					passData.camera = val.camera;
					val3.SetRenderFunc<PassData>((BaseRenderFunc<PassData, RasterGraphContext>)delegate(PassData data, RasterGraphContext context)
					{
						//IL_0001: Unknown result type (might be due to invalid IL or missing references)
						CommandBufferWrapper cmd = new CommandBufferWrapper(context.cmd);
						ImGuiBehaviour.ExecuteCustomRenderGraphPass(in cmd, data.camera);
					});
				}
				finally
				{
					((IDisposable)val3)?.Dispose();
				}
			}

			public override void FrameCleanup(CommandBuffer cmd)
			{
			}
		}

		private DearImGuiURPRenderPass _scriptablePass;

		public override void Create()
		{
			DearImGuiURPRenderPass dearImGuiURPRenderPass = new DearImGuiURPRenderPass();
			((ScriptableRenderPass)dearImGuiURPRenderPass).renderPassEvent = (RenderPassEvent)1000;
			_scriptablePass = dearImGuiURPRenderPass;
		}

		public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
		{
			AddRenderPasses(renderer, ((CameraData)(ref renderingData.cameraData)).camera);
		}

		public void AddRenderPasses(ScriptableRenderer renderer, Camera camera)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Invalid comparison between Unknown and I4
			if (ImGuiController.HasController)
			{
				UniversalAdditionalCameraData universalAdditionalCameraData = CameraExtensions.GetUniversalAdditionalCameraData(camera);
				if (!((Object)(object)universalAdditionalCameraData != (Object)null) || (int)universalAdditionalCameraData.renderType <= 0)
				{
					renderer.EnqueuePass((ScriptableRenderPass)(object)_scriptablePass);
				}
			}
		}
	}
	public class IntPtrEqualityComparer : IEqualityComparer<IntPtr>
	{
		public static IntPtrEqualityComparer Instance { get; } = new IntPtrEqualityComparer();


		private IntPtrEqualityComparer()
		{
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool Equals(IntPtr p1, IntPtr p2)
		{
			return p1 == p2;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public int GetHashCode(IntPtr ptr)
		{
			return ptr.GetHashCode();
		}
	}
	internal class TwoWayDictionary<T1, T2>
	{
		private Dictionary<T1, T2> _forwards = new Dictionary<T1, T2>();

		private Dictionary<T2, T1> _backwards = new Dictionary<T2, T1>();

		public IReadOnlyDictionary<T1, T2> Forwards => _forwards;

		public IReadOnlyDictionary<T2, T1> Backwards => _backwards;

		public IEnumerable<T1> Set1 => Forwards.Keys;

		public IEnumerable<T2> Set2 => Backwards.Keys;

		public T1 this[T2 index]
		{
			get
			{
				return _backwards[index];
			}
			set
			{
				if (_backwards.TryGetValue(index, out var value2))
				{
					_forwards.Remove(value2);
				}
				_backwards[index] = value;
				_forwards[value] = index;
			}
		}

		public T2 this[T1 index]
		{
			get
			{
				return _forwards[index];
			}
			set
			{
				if (_forwards.TryGetValue(index, out var value2))
				{
					_backwards.Remove(value2);
				}
				_forwards[index] = value;
				_backwards[value] = index;
			}
		}

		public int Count => _forwards.Count;

		public TwoWayDictionary()
		{
			_forwards = new Dictionary<T1, T2>();
			_backwards = new Dictionary<T2, T1>();
		}

		public TwoWayDictionary(int capacity)
		{
			_forwards = new Dictionary<T1, T2>(capacity);
			_backwards = new Dictionary<T2, T1>(capacity);
		}

		public TwoWayDictionary(Dictionary<T1, T2> initial)
		{
			_forwards = initial;
			_backwards = initial.ToDictionary<KeyValuePair<T1, T2>, T2, T1>((KeyValuePair<T1, T2> kvp) => kvp.Value, (KeyValuePair<T1, T2> kvp) => kvp.Key);
		}

		public TwoWayDictionary(Dictionary<T2, T1> initial)
		{
			_backwards = initial;
			_forwards = initial.ToDictionary<KeyValuePair<T2, T1>, T1, T2>((KeyValuePair<T2, T1> kvp) => kvp.Value, (KeyValuePair<T2, T1> kvp) => kvp.Key);
		}

		public bool Contains(T1 item)
		{
			return _forwards.ContainsKey(item);
		}

		public bool Contains(T2 item)
		{
			return _backwards.ContainsKey(item);
		}

		public bool Remove(T1 item)
		{
			if (!Contains(item))
			{
				return false;
			}
			T2 key = _forwards[item];
			_backwards.Remove(key);
			_forwards.Remove(item);
			return true;
		}

		public bool Remove(T2 item)
		{
			if (!Contains(item))
			{
				return false;
			}
			T1 key = _backwards[item];
			_forwards.Remove(key);
			_backwards.Remove(item);
			return true;
		}

		public void Clear()
		{
			_forwards.Clear();
			_backwards.Clear();
		}
	}
}
namespace UBImGui.Samples
{
	public class DemoWindow : MonoBehaviour
	{
		private void OnEnable()
		{
			ImGui.Layout += ImGuiOnLayout;
		}

		private void OnDisable()
		{
			ImGui.Layout -= ImGuiOnLayout;
		}

		private void ImGuiOnLayout()
		{
			ImGui.ShowDemoWindow();
		}
	}
}