Dalamud/imgui/Dalamud.ImGui/Internals/Functions/Functions.006.cs

// ------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
// ------------------------------------------------------------------------------

using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using HexaGen.Runtime;
using System.Numerics;

namespace Dalamud.Bindings.ImGui
{
	public unsafe partial class ImGuiP
	{

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void* ImFileLoadToMemory(string filename, ReadOnlySpan<byte> mode, int paddingBytes)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (filename != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(filename);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(filename, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (byte* pmode = mode)
			{
				void* ret = ImFileLoadToMemoryNative(pStr0, (byte*)pmode, (ulong*)(default), paddingBytes);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void* ImFileLoadToMemory(byte* filename, byte* mode, ref nuint outFileSize, int paddingBytes)
		{
			fixed (nuint* poutFileSize = &outFileSize)
			{
				void* ret = ImFileLoadToMemoryNative(filename, mode, (ulong*)poutFileSize, paddingBytes);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void* ImFileLoadToMemory(byte* filename, byte* mode, ref nuint outFileSize)
		{
			fixed (nuint* poutFileSize = &outFileSize)
			{
				void* ret = ImFileLoadToMemoryNative(filename, mode, (ulong*)poutFileSize, (int)(0));
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void* ImFileLoadToMemory(ref byte filename, byte* mode, ref nuint outFileSize, int paddingBytes)
		{
			fixed (byte* pfilename = &filename)
			{
				fixed (nuint* poutFileSize = &outFileSize)
				{
					void* ret = ImFileLoadToMemoryNative((byte*)pfilename, mode, (ulong*)poutFileSize, paddingBytes);
					return ret;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void* ImFileLoadToMemory(ref byte filename, byte* mode, ref nuint outFileSize)
		{
			fixed (byte* pfilename = &filename)
			{
				fixed (nuint* poutFileSize = &outFileSize)
				{
					void* ret = ImFileLoadToMemoryNative((byte*)pfilename, mode, (ulong*)poutFileSize, (int)(0));
					return ret;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void* ImFileLoadToMemory(ReadOnlySpan<byte> filename, byte* mode, ref nuint outFileSize, int paddingBytes)
		{
			fixed (byte* pfilename = filename)
			{
				fixed (nuint* poutFileSize = &outFileSize)
				{
					void* ret = ImFileLoadToMemoryNative((byte*)pfilename, mode, (ulong*)poutFileSize, paddingBytes);
					return ret;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void* ImFileLoadToMemory(ReadOnlySpan<byte> filename, byte* mode, ref nuint outFileSize)
		{
			fixed (byte* pfilename = filename)
			{
				fixed (nuint* poutFileSize = &outFileSize)
				{
					void* ret = ImFileLoadToMemoryNative((byte*)pfilename, mode, (ulong*)poutFileSize, (int)(0));
					return ret;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void* ImFileLoadToMemory(string filename, byte* mode, ref nuint outFileSize, int paddingBytes)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (filename != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(filename);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(filename, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (nuint* poutFileSize = &outFileSize)
			{
				void* ret = ImFileLoadToMemoryNative(pStr0, mode, (ulong*)poutFileSize, paddingBytes);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void* ImFileLoadToMemory(string filename, byte* mode, ref nuint outFileSize)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (filename != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(filename);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(filename, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (nuint* poutFileSize = &outFileSize)
			{
				void* ret = ImFileLoadToMemoryNative(pStr0, mode, (ulong*)poutFileSize, (int)(0));
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void* ImFileLoadToMemory(byte* filename, ref byte mode, ref nuint outFileSize, int paddingBytes)
		{
			fixed (byte* pmode = &mode)
			{
				fixed (nuint* poutFileSize = &outFileSize)
				{
					void* ret = ImFileLoadToMemoryNative(filename, (byte*)pmode, (ulong*)poutFileSize, paddingBytes);
					return ret;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void* ImFileLoadToMemory(byte* filename, ref byte mode, ref nuint outFileSize)
		{
			fixed (byte* pmode = &mode)
			{
				fixed (nuint* poutFileSize = &outFileSize)
				{
					void* ret = ImFileLoadToMemoryNative(filename, (byte*)pmode, (ulong*)poutFileSize, (int)(0));
					return ret;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void* ImFileLoadToMemory(byte* filename, ReadOnlySpan<byte> mode, ref nuint outFileSize, int paddingBytes)
		{
			fixed (byte* pmode = mode)
			{
				fixed (nuint* poutFileSize = &outFileSize)
				{
					void* ret = ImFileLoadToMemoryNative(filename, (byte*)pmode, (ulong*)poutFileSize, paddingBytes);
					return ret;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void* ImFileLoadToMemory(byte* filename, ReadOnlySpan<byte> mode, ref nuint outFileSize)
		{
			fixed (byte* pmode = mode)
			{
				fixed (nuint* poutFileSize = &outFileSize)
				{
					void* ret = ImFileLoadToMemoryNative(filename, (byte*)pmode, (ulong*)poutFileSize, (int)(0));
					return ret;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void* ImFileLoadToMemory(byte* filename, string mode, ref nuint outFileSize, int paddingBytes)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (mode != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(mode);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(mode, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (nuint* poutFileSize = &outFileSize)
			{
				void* ret = ImFileLoadToMemoryNative(filename, pStr0, (ulong*)poutFileSize, paddingBytes);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void* ImFileLoadToMemory(byte* filename, string mode, ref nuint outFileSize)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (mode != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(mode);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(mode, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (nuint* poutFileSize = &outFileSize)
			{
				void* ret = ImFileLoadToMemoryNative(filename, pStr0, (ulong*)poutFileSize, (int)(0));
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void* ImFileLoadToMemory(ref byte filename, ref byte mode, ref nuint outFileSize, int paddingBytes)
		{
			fixed (byte* pfilename = &filename)
			{
				fixed (byte* pmode = &mode)
				{
					fixed (nuint* poutFileSize = &outFileSize)
					{
						void* ret = ImFileLoadToMemoryNative((byte*)pfilename, (byte*)pmode, (ulong*)poutFileSize, paddingBytes);
						return ret;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void* ImFileLoadToMemory(ref byte filename, ref byte mode, ref nuint outFileSize)
		{
			fixed (byte* pfilename = &filename)
			{
				fixed (byte* pmode = &mode)
				{
					fixed (nuint* poutFileSize = &outFileSize)
					{
						void* ret = ImFileLoadToMemoryNative((byte*)pfilename, (byte*)pmode, (ulong*)poutFileSize, (int)(0));
						return ret;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void* ImFileLoadToMemory(ReadOnlySpan<byte> filename, ReadOnlySpan<byte> mode, ref nuint outFileSize, int paddingBytes)
		{
			fixed (byte* pfilename = filename)
			{
				fixed (byte* pmode = mode)
				{
					fixed (nuint* poutFileSize = &outFileSize)
					{
						void* ret = ImFileLoadToMemoryNative((byte*)pfilename, (byte*)pmode, (ulong*)poutFileSize, paddingBytes);
						return ret;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void* ImFileLoadToMemory(ReadOnlySpan<byte> filename, ReadOnlySpan<byte> mode, ref nuint outFileSize)
		{
			fixed (byte* pfilename = filename)
			{
				fixed (byte* pmode = mode)
				{
					fixed (nuint* poutFileSize = &outFileSize)
					{
						void* ret = ImFileLoadToMemoryNative((byte*)pfilename, (byte*)pmode, (ulong*)poutFileSize, (int)(0));
						return ret;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void* ImFileLoadToMemory(string filename, string mode, ref nuint outFileSize, int paddingBytes)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (filename != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(filename);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(filename, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			byte* pStr1 = null;
			int pStrSize1 = 0;
			if (mode != null)
			{
				pStrSize1 = Utils.GetByteCountUTF8(mode);
				if (pStrSize1 >= Utils.MaxStackallocSize)
				{
					pStr1 = Utils.Alloc<byte>(pStrSize1 + 1);
				}
				else
				{
					byte* pStrStack1 = stackalloc byte[pStrSize1 + 1];
					pStr1 = pStrStack1;
				}
				int pStrOffset1 = Utils.EncodeStringUTF8(mode, pStr1, pStrSize1);
				pStr1[pStrOffset1] = 0;
			}
			fixed (nuint* poutFileSize = &outFileSize)
			{
				void* ret = ImFileLoadToMemoryNative(pStr0, pStr1, (ulong*)poutFileSize, paddingBytes);
				if (pStrSize1 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr1);
				}
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void* ImFileLoadToMemory(string filename, string mode, ref nuint outFileSize)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (filename != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(filename);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(filename, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			byte* pStr1 = null;
			int pStrSize1 = 0;
			if (mode != null)
			{
				pStrSize1 = Utils.GetByteCountUTF8(mode);
				if (pStrSize1 >= Utils.MaxStackallocSize)
				{
					pStr1 = Utils.Alloc<byte>(pStrSize1 + 1);
				}
				else
				{
					byte* pStrStack1 = stackalloc byte[pStrSize1 + 1];
					pStr1 = pStrStack1;
				}
				int pStrOffset1 = Utils.EncodeStringUTF8(mode, pStr1, pStrSize1);
				pStr1[pStrOffset1] = 0;
			}
			fixed (nuint* poutFileSize = &outFileSize)
			{
				void* ret = ImFileLoadToMemoryNative(pStr0, pStr1, (ulong*)poutFileSize, (int)(0));
				if (pStrSize1 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr1);
				}
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void* ImFileLoadToMemory(ref byte filename, ReadOnlySpan<byte> mode, ref nuint outFileSize, int paddingBytes)
		{
			fixed (byte* pfilename = &filename)
			{
				fixed (byte* pmode = mode)
				{
					fixed (nuint* poutFileSize = &outFileSize)
					{
						void* ret = ImFileLoadToMemoryNative((byte*)pfilename, (byte*)pmode, (ulong*)poutFileSize, paddingBytes);
						return ret;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void* ImFileLoadToMemory(ref byte filename, ReadOnlySpan<byte> mode, ref nuint outFileSize)
		{
			fixed (byte* pfilename = &filename)
			{
				fixed (byte* pmode = mode)
				{
					fixed (nuint* poutFileSize = &outFileSize)
					{
						void* ret = ImFileLoadToMemoryNative((byte*)pfilename, (byte*)pmode, (ulong*)poutFileSize, (int)(0));
						return ret;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void* ImFileLoadToMemory(ref byte filename, string mode, ref nuint outFileSize, int paddingBytes)
		{
			fixed (byte* pfilename = &filename)
			{
				byte* pStr0 = null;
				int pStrSize0 = 0;
				if (mode != null)
				{
					pStrSize0 = Utils.GetByteCountUTF8(mode);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
					}
					else
					{
						byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
						pStr0 = pStrStack0;
					}
					int pStrOffset0 = Utils.EncodeStringUTF8(mode, pStr0, pStrSize0);
					pStr0[pStrOffset0] = 0;
				}
				fixed (nuint* poutFileSize = &outFileSize)
				{
					void* ret = ImFileLoadToMemoryNative((byte*)pfilename, pStr0, (ulong*)poutFileSize, paddingBytes);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						Utils.Free(pStr0);
					}
					return ret;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void* ImFileLoadToMemory(ref byte filename, string mode, ref nuint outFileSize)
		{
			fixed (byte* pfilename = &filename)
			{
				byte* pStr0 = null;
				int pStrSize0 = 0;
				if (mode != null)
				{
					pStrSize0 = Utils.GetByteCountUTF8(mode);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
					}
					else
					{
						byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
						pStr0 = pStrStack0;
					}
					int pStrOffset0 = Utils.EncodeStringUTF8(mode, pStr0, pStrSize0);
					pStr0[pStrOffset0] = 0;
				}
				fixed (nuint* poutFileSize = &outFileSize)
				{
					void* ret = ImFileLoadToMemoryNative((byte*)pfilename, pStr0, (ulong*)poutFileSize, (int)(0));
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						Utils.Free(pStr0);
					}
					return ret;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void* ImFileLoadToMemory(ReadOnlySpan<byte> filename, ref byte mode, ref nuint outFileSize, int paddingBytes)
		{
			fixed (byte* pfilename = filename)
			{
				fixed (byte* pmode = &mode)
				{
					fixed (nuint* poutFileSize = &outFileSize)
					{
						void* ret = ImFileLoadToMemoryNative((byte*)pfilename, (byte*)pmode, (ulong*)poutFileSize, paddingBytes);
						return ret;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void* ImFileLoadToMemory(ReadOnlySpan<byte> filename, ref byte mode, ref nuint outFileSize)
		{
			fixed (byte* pfilename = filename)
			{
				fixed (byte* pmode = &mode)
				{
					fixed (nuint* poutFileSize = &outFileSize)
					{
						void* ret = ImFileLoadToMemoryNative((byte*)pfilename, (byte*)pmode, (ulong*)poutFileSize, (int)(0));
						return ret;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void* ImFileLoadToMemory(ReadOnlySpan<byte> filename, string mode, ref nuint outFileSize, int paddingBytes)
		{
			fixed (byte* pfilename = filename)
			{
				byte* pStr0 = null;
				int pStrSize0 = 0;
				if (mode != null)
				{
					pStrSize0 = Utils.GetByteCountUTF8(mode);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
					}
					else
					{
						byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
						pStr0 = pStrStack0;
					}
					int pStrOffset0 = Utils.EncodeStringUTF8(mode, pStr0, pStrSize0);
					pStr0[pStrOffset0] = 0;
				}
				fixed (nuint* poutFileSize = &outFileSize)
				{
					void* ret = ImFileLoadToMemoryNative((byte*)pfilename, pStr0, (ulong*)poutFileSize, paddingBytes);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						Utils.Free(pStr0);
					}
					return ret;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void* ImFileLoadToMemory(ReadOnlySpan<byte> filename, string mode, ref nuint outFileSize)
		{
			fixed (byte* pfilename = filename)
			{
				byte* pStr0 = null;
				int pStrSize0 = 0;
				if (mode != null)
				{
					pStrSize0 = Utils.GetByteCountUTF8(mode);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
					}
					else
					{
						byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
						pStr0 = pStrStack0;
					}
					int pStrOffset0 = Utils.EncodeStringUTF8(mode, pStr0, pStrSize0);
					pStr0[pStrOffset0] = 0;
				}
				fixed (nuint* poutFileSize = &outFileSize)
				{
					void* ret = ImFileLoadToMemoryNative((byte*)pfilename, pStr0, (ulong*)poutFileSize, (int)(0));
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						Utils.Free(pStr0);
					}
					return ret;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void* ImFileLoadToMemory(string filename, ref byte mode, ref nuint outFileSize, int paddingBytes)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (filename != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(filename);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(filename, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (byte* pmode = &mode)
			{
				fixed (nuint* poutFileSize = &outFileSize)
				{
					void* ret = ImFileLoadToMemoryNative(pStr0, (byte*)pmode, (ulong*)poutFileSize, paddingBytes);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						Utils.Free(pStr0);
					}
					return ret;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void* ImFileLoadToMemory(string filename, ref byte mode, ref nuint outFileSize)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (filename != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(filename);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(filename, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (byte* pmode = &mode)
			{
				fixed (nuint* poutFileSize = &outFileSize)
				{
					void* ret = ImFileLoadToMemoryNative(pStr0, (byte*)pmode, (ulong*)poutFileSize, (int)(0));
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						Utils.Free(pStr0);
					}
					return ret;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void* ImFileLoadToMemory(string filename, ReadOnlySpan<byte> mode, ref nuint outFileSize, int paddingBytes)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (filename != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(filename);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(filename, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (byte* pmode = mode)
			{
				fixed (nuint* poutFileSize = &outFileSize)
				{
					void* ret = ImFileLoadToMemoryNative(pStr0, (byte*)pmode, (ulong*)poutFileSize, paddingBytes);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						Utils.Free(pStr0);
					}
					return ret;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void* ImFileLoadToMemory(string filename, ReadOnlySpan<byte> mode, ref nuint outFileSize)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (filename != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(filename);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(filename, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (byte* pmode = mode)
			{
				fixed (nuint* poutFileSize = &outFileSize)
				{
					void* ret = ImFileLoadToMemoryNative(pStr0, (byte*)pmode, (ulong*)poutFileSize, (int)(0));
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						Utils.Free(pStr0);
					}
					return ret;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static float ImPowNative(float x, float y)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<float, float, float>)funcTable[730])(x, y);
			#else
			return (float)((delegate* unmanaged[Cdecl]<float, float, float>)funcTable[730])(x, y);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float ImPow(float x, float y)
		{
			float ret = ImPowNative(x, y);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static double ImPowNative(double x, double y)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<double, double, double>)funcTable[731])(x, y);
			#else
			return (double)((delegate* unmanaged[Cdecl]<double, double, double>)funcTable[731])(x, y);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static double ImPow(double x, double y)
		{
			double ret = ImPowNative(x, y);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static float ImLogNative(float x)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<float, float>)funcTable[732])(x);
			#else
			return (float)((delegate* unmanaged[Cdecl]<float, float>)funcTable[732])(x);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float ImLog(float x)
		{
			float ret = ImLogNative(x);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static double ImLogNative(double x)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<double, double>)funcTable[733])(x);
			#else
			return (double)((delegate* unmanaged[Cdecl]<double, double>)funcTable[733])(x);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static double ImLog(double x)
		{
			double ret = ImLogNative(x);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static int ImAbsNative(int x)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<int, int>)funcTable[734])(x);
			#else
			return (int)((delegate* unmanaged[Cdecl]<int, int>)funcTable[734])(x);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int ImAbs(int x)
		{
			int ret = ImAbsNative(x);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static float ImAbsNative(float x)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<float, float>)funcTable[735])(x);
			#else
			return (float)((delegate* unmanaged[Cdecl]<float, float>)funcTable[735])(x);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float ImAbs(float x)
		{
			float ret = ImAbsNative(x);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static double ImAbsNative(double x)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<double, double>)funcTable[736])(x);
			#else
			return (double)((delegate* unmanaged[Cdecl]<double, double>)funcTable[736])(x);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static double ImAbs(double x)
		{
			double ret = ImAbsNative(x);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static float ImSignNative(float x)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<float, float>)funcTable[737])(x);
			#else
			return (float)((delegate* unmanaged[Cdecl]<float, float>)funcTable[737])(x);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float ImSign(float x)
		{
			float ret = ImSignNative(x);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static double ImSignNative(double x)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<double, double>)funcTable[738])(x);
			#else
			return (double)((delegate* unmanaged[Cdecl]<double, double>)funcTable[738])(x);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static double ImSign(double x)
		{
			double ret = ImSignNative(x);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static float ImRsqrtNative(float x)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<float, float>)funcTable[739])(x);
			#else
			return (float)((delegate* unmanaged[Cdecl]<float, float>)funcTable[739])(x);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float ImRsqrt(float x)
		{
			float ret = ImRsqrtNative(x);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static double ImRsqrtNative(double x)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<double, double>)funcTable[740])(x);
			#else
			return (double)((delegate* unmanaged[Cdecl]<double, double>)funcTable[740])(x);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static double ImRsqrt(double x)
		{
			double ret = ImRsqrtNative(x);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ImMinNative(Vector2* pOut, Vector2 lhs, Vector2 rhs)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<Vector2*, Vector2, Vector2, void>)funcTable[741])(pOut, lhs, rhs);
			#else
			((delegate* unmanaged[Cdecl]<nint, Vector2, Vector2, void>)funcTable[741])((nint)pOut, lhs, rhs);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 ImMin(Vector2 lhs, Vector2 rhs)
		{
			Vector2 ret;
			ImMinNative(&ret, lhs, rhs);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMin(Vector2* pOut, Vector2 lhs, Vector2 rhs)
		{
			ImMinNative(pOut, lhs, rhs);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMin(ref Vector2 pOut, Vector2 lhs, Vector2 rhs)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImMinNative((Vector2*)ppOut, lhs, rhs);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ImMaxNative(Vector2* pOut, Vector2 lhs, Vector2 rhs)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<Vector2*, Vector2, Vector2, void>)funcTable[742])(pOut, lhs, rhs);
			#else
			((delegate* unmanaged[Cdecl]<nint, Vector2, Vector2, void>)funcTable[742])((nint)pOut, lhs, rhs);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 ImMax(Vector2 lhs, Vector2 rhs)
		{
			Vector2 ret;
			ImMaxNative(&ret, lhs, rhs);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMax(Vector2* pOut, Vector2 lhs, Vector2 rhs)
		{
			ImMaxNative(pOut, lhs, rhs);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMax(ref Vector2 pOut, Vector2 lhs, Vector2 rhs)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImMaxNative((Vector2*)ppOut, lhs, rhs);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ImClampNative(Vector2* pOut, Vector2 v, Vector2 mn, Vector2 mx)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<Vector2*, Vector2, Vector2, Vector2, void>)funcTable[743])(pOut, v, mn, mx);
			#else
			((delegate* unmanaged[Cdecl]<nint, Vector2, Vector2, Vector2, void>)funcTable[743])((nint)pOut, v, mn, mx);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 ImClamp(Vector2 v, Vector2 mn, Vector2 mx)
		{
			Vector2 ret;
			ImClampNative(&ret, v, mn, mx);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImClamp(Vector2* pOut, Vector2 v, Vector2 mn, Vector2 mx)
		{
			ImClampNative(pOut, v, mn, mx);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImClamp(ref Vector2 pOut, Vector2 v, Vector2 mn, Vector2 mx)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImClampNative((Vector2*)ppOut, v, mn, mx);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ImLerpNative(Vector2* pOut, Vector2 a, Vector2 b, float t)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<Vector2*, Vector2, Vector2, float, void>)funcTable[744])(pOut, a, b, t);
			#else
			((delegate* unmanaged[Cdecl]<nint, Vector2, Vector2, float, void>)funcTable[744])((nint)pOut, a, b, t);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 ImLerp(Vector2 a, Vector2 b, float t)
		{
			Vector2 ret;
			ImLerpNative(&ret, a, b, t);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImLerp(Vector2* pOut, Vector2 a, Vector2 b, float t)
		{
			ImLerpNative(pOut, a, b, t);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImLerp(ref Vector2 pOut, Vector2 a, Vector2 b, float t)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImLerpNative((Vector2*)ppOut, a, b, t);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ImLerpNative(Vector2* pOut, Vector2 a, Vector2 b, Vector2 t)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<Vector2*, Vector2, Vector2, Vector2, void>)funcTable[745])(pOut, a, b, t);
			#else
			((delegate* unmanaged[Cdecl]<nint, Vector2, Vector2, Vector2, void>)funcTable[745])((nint)pOut, a, b, t);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 ImLerp(Vector2 a, Vector2 b, Vector2 t)
		{
			Vector2 ret;
			ImLerpNative(&ret, a, b, t);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImLerp(Vector2* pOut, Vector2 a, Vector2 b, Vector2 t)
		{
			ImLerpNative(pOut, a, b, t);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImLerp(ref Vector2 pOut, Vector2 a, Vector2 b, Vector2 t)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImLerpNative((Vector2*)ppOut, a, b, t);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ImLerpNative(Vector4* pOut, Vector4 a, Vector4 b, float t)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<Vector4*, Vector4, Vector4, float, void>)funcTable[746])(pOut, a, b, t);
			#else
			((delegate* unmanaged[Cdecl]<nint, Vector4, Vector4, float, void>)funcTable[746])((nint)pOut, a, b, t);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector4 ImLerp(Vector4 a, Vector4 b, float t)
		{
			Vector4 ret;
			ImLerpNative(&ret, a, b, t);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImLerp(Vector4* pOut, Vector4 a, Vector4 b, float t)
		{
			ImLerpNative(pOut, a, b, t);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImLerp(ref Vector4 pOut, Vector4 a, Vector4 b, float t)
		{
			fixed (Vector4* ppOut = &pOut)
			{
				ImLerpNative((Vector4*)ppOut, a, b, t);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static float ImSaturateNative(float f)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<float, float>)funcTable[747])(f);
			#else
			return (float)((delegate* unmanaged[Cdecl]<float, float>)funcTable[747])(f);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float ImSaturate(float f)
		{
			float ret = ImSaturateNative(f);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static float ImLengthSqrNative(Vector2 lhs)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<Vector2, float>)funcTable[748])(lhs);
			#else
			return (float)((delegate* unmanaged[Cdecl]<Vector2, float>)funcTable[748])(lhs);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float ImLengthSqr(Vector2 lhs)
		{
			float ret = ImLengthSqrNative(lhs);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static float ImLengthSqrNative(Vector4 lhs)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<Vector4, float>)funcTable[749])(lhs);
			#else
			return (float)((delegate* unmanaged[Cdecl]<Vector4, float>)funcTable[749])(lhs);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float ImLengthSqr(Vector4 lhs)
		{
			float ret = ImLengthSqrNative(lhs);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static float ImInvLengthNative(Vector2 lhs, float failValue)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<Vector2, float, float>)funcTable[750])(lhs, failValue);
			#else
			return (float)((delegate* unmanaged[Cdecl]<Vector2, float, float>)funcTable[750])(lhs, failValue);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float ImInvLength(Vector2 lhs, float failValue)
		{
			float ret = ImInvLengthNative(lhs, failValue);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static float ImFloorNative(float f)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<float, float>)funcTable[751])(f);
			#else
			return (float)((delegate* unmanaged[Cdecl]<float, float>)funcTable[751])(f);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float ImFloor(float f)
		{
			float ret = ImFloorNative(f);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static float ImFloorSignedNative(float f)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<float, float>)funcTable[752])(f);
			#else
			return (float)((delegate* unmanaged[Cdecl]<float, float>)funcTable[752])(f);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float ImFloorSigned(float f)
		{
			float ret = ImFloorSignedNative(f);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ImFloorNative(Vector2* pOut, Vector2 v)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<Vector2*, Vector2, void>)funcTable[753])(pOut, v);
			#else
			((delegate* unmanaged[Cdecl]<nint, Vector2, void>)funcTable[753])((nint)pOut, v);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 ImFloor(Vector2 v)
		{
			Vector2 ret;
			ImFloorNative(&ret, v);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImFloor(Vector2* pOut, Vector2 v)
		{
			ImFloorNative(pOut, v);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImFloor(ref Vector2 pOut, Vector2 v)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImFloorNative((Vector2*)ppOut, v);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ImFloorSignedNative(Vector2* pOut, Vector2 v)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<Vector2*, Vector2, void>)funcTable[754])(pOut, v);
			#else
			((delegate* unmanaged[Cdecl]<nint, Vector2, void>)funcTable[754])((nint)pOut, v);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 ImFloorSigned(Vector2 v)
		{
			Vector2 ret;
			ImFloorSignedNative(&ret, v);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImFloorSigned(Vector2* pOut, Vector2 v)
		{
			ImFloorSignedNative(pOut, v);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImFloorSigned(ref Vector2 pOut, Vector2 v)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImFloorSignedNative((Vector2*)ppOut, v);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static int ImModPositiveNative(int a, int b)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<int, int, int>)funcTable[755])(a, b);
			#else
			return (int)((delegate* unmanaged[Cdecl]<int, int, int>)funcTable[755])(a, b);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int ImModPositive(int a, int b)
		{
			int ret = ImModPositiveNative(a, b);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static float ImDotNative(Vector2 a, Vector2 b)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<Vector2, Vector2, float>)funcTable[756])(a, b);
			#else
			return (float)((delegate* unmanaged[Cdecl]<Vector2, Vector2, float>)funcTable[756])(a, b);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float ImDot(Vector2 a, Vector2 b)
		{
			float ret = ImDotNative(a, b);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ImRotateNative(Vector2* pOut, Vector2 v, float cosA, float sinA)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<Vector2*, Vector2, float, float, void>)funcTable[757])(pOut, v, cosA, sinA);
			#else
			((delegate* unmanaged[Cdecl]<nint, Vector2, float, float, void>)funcTable[757])((nint)pOut, v, cosA, sinA);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 ImRotate(Vector2 v, float cosA, float sinA)
		{
			Vector2 ret;
			ImRotateNative(&ret, v, cosA, sinA);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImRotate(Vector2* pOut, Vector2 v, float cosA, float sinA)
		{
			ImRotateNative(pOut, v, cosA, sinA);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImRotate(ref Vector2 pOut, Vector2 v, float cosA, float sinA)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImRotateNative((Vector2*)ppOut, v, cosA, sinA);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static float ImLinearSweepNative(float current, float target, float speed)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<float, float, float, float>)funcTable[758])(current, target, speed);
			#else
			return (float)((delegate* unmanaged[Cdecl]<float, float, float, float>)funcTable[758])(current, target, speed);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float ImLinearSweep(float current, float target, float speed)
		{
			float ret = ImLinearSweepNative(current, target, speed);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ImMulNative(Vector2* pOut, Vector2 lhs, Vector2 rhs)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<Vector2*, Vector2, Vector2, void>)funcTable[759])(pOut, lhs, rhs);
			#else
			((delegate* unmanaged[Cdecl]<nint, Vector2, Vector2, void>)funcTable[759])((nint)pOut, lhs, rhs);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 ImMul(Vector2 lhs, Vector2 rhs)
		{
			Vector2 ret;
			ImMulNative(&ret, lhs, rhs);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMul(Vector2* pOut, Vector2 lhs, Vector2 rhs)
		{
			ImMulNative(pOut, lhs, rhs);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMul(ref Vector2 pOut, Vector2 lhs, Vector2 rhs)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImMulNative((Vector2*)ppOut, lhs, rhs);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte ImIsFloatAboveGuaranteedIntegerPrecisionNative(float f)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<float, byte>)funcTable[760])(f);
			#else
			return (byte)((delegate* unmanaged[Cdecl]<float, byte>)funcTable[760])(f);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ImIsFloatAboveGuaranteedIntegerPrecision(float f)
		{
			byte ret = ImIsFloatAboveGuaranteedIntegerPrecisionNative(f);
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ImBezierCubicCalcNative(Vector2* pOut, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float t)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<Vector2*, Vector2, Vector2, Vector2, Vector2, float, void>)funcTable[761])(pOut, p1, p2, p3, p4, t);
			#else
			((delegate* unmanaged[Cdecl]<nint, Vector2, Vector2, Vector2, Vector2, float, void>)funcTable[761])((nint)pOut, p1, p2, p3, p4, t);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 ImBezierCubicCalc(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float t)
		{
			Vector2 ret;
			ImBezierCubicCalcNative(&ret, p1, p2, p3, p4, t);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImBezierCubicCalc(Vector2* pOut, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float t)
		{
			ImBezierCubicCalcNative(pOut, p1, p2, p3, p4, t);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImBezierCubicCalc(ref Vector2 pOut, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float t)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImBezierCubicCalcNative((Vector2*)ppOut, p1, p2, p3, p4, t);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ImBezierCubicClosestPointNative(Vector2* pOut, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, Vector2 p, int numSegments)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<Vector2*, Vector2, Vector2, Vector2, Vector2, Vector2, int, void>)funcTable[762])(pOut, p1, p2, p3, p4, p, numSegments);
			#else
			((delegate* unmanaged[Cdecl]<nint, Vector2, Vector2, Vector2, Vector2, Vector2, int, void>)funcTable[762])((nint)pOut, p1, p2, p3, p4, p, numSegments);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 ImBezierCubicClosestPoint(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, Vector2 p, int numSegments)
		{
			Vector2 ret;
			ImBezierCubicClosestPointNative(&ret, p1, p2, p3, p4, p, numSegments);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImBezierCubicClosestPoint(Vector2* pOut, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, Vector2 p, int numSegments)
		{
			ImBezierCubicClosestPointNative(pOut, p1, p2, p3, p4, p, numSegments);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImBezierCubicClosestPoint(ref Vector2 pOut, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, Vector2 p, int numSegments)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImBezierCubicClosestPointNative((Vector2*)ppOut, p1, p2, p3, p4, p, numSegments);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ImBezierCubicClosestPointCasteljauNative(Vector2* pOut, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, Vector2 p, float tessTol)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<Vector2*, Vector2, Vector2, Vector2, Vector2, Vector2, float, void>)funcTable[763])(pOut, p1, p2, p3, p4, p, tessTol);
			#else
			((delegate* unmanaged[Cdecl]<nint, Vector2, Vector2, Vector2, Vector2, Vector2, float, void>)funcTable[763])((nint)pOut, p1, p2, p3, p4, p, tessTol);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 ImBezierCubicClosestPointCasteljau(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, Vector2 p, float tessTol)
		{
			Vector2 ret;
			ImBezierCubicClosestPointCasteljauNative(&ret, p1, p2, p3, p4, p, tessTol);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImBezierCubicClosestPointCasteljau(Vector2* pOut, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, Vector2 p, float tessTol)
		{
			ImBezierCubicClosestPointCasteljauNative(pOut, p1, p2, p3, p4, p, tessTol);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImBezierCubicClosestPointCasteljau(ref Vector2 pOut, Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, Vector2 p, float tessTol)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImBezierCubicClosestPointCasteljauNative((Vector2*)ppOut, p1, p2, p3, p4, p, tessTol);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ImBezierQuadraticCalcNative(Vector2* pOut, Vector2 p1, Vector2 p2, Vector2 p3, float t)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<Vector2*, Vector2, Vector2, Vector2, float, void>)funcTable[764])(pOut, p1, p2, p3, t);
			#else
			((delegate* unmanaged[Cdecl]<nint, Vector2, Vector2, Vector2, float, void>)funcTable[764])((nint)pOut, p1, p2, p3, t);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 ImBezierQuadraticCalc(Vector2 p1, Vector2 p2, Vector2 p3, float t)
		{
			Vector2 ret;
			ImBezierQuadraticCalcNative(&ret, p1, p2, p3, t);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImBezierQuadraticCalc(Vector2* pOut, Vector2 p1, Vector2 p2, Vector2 p3, float t)
		{
			ImBezierQuadraticCalcNative(pOut, p1, p2, p3, t);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImBezierQuadraticCalc(ref Vector2 pOut, Vector2 p1, Vector2 p2, Vector2 p3, float t)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImBezierQuadraticCalcNative((Vector2*)ppOut, p1, p2, p3, t);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ImLineClosestPointNative(Vector2* pOut, Vector2 a, Vector2 b, Vector2 p)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<Vector2*, Vector2, Vector2, Vector2, void>)funcTable[765])(pOut, a, b, p);
			#else
			((delegate* unmanaged[Cdecl]<nint, Vector2, Vector2, Vector2, void>)funcTable[765])((nint)pOut, a, b, p);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 ImLineClosestPoint(Vector2 a, Vector2 b, Vector2 p)
		{
			Vector2 ret;
			ImLineClosestPointNative(&ret, a, b, p);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImLineClosestPoint(Vector2* pOut, Vector2 a, Vector2 b, Vector2 p)
		{
			ImLineClosestPointNative(pOut, a, b, p);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImLineClosestPoint(ref Vector2 pOut, Vector2 a, Vector2 b, Vector2 p)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImLineClosestPointNative((Vector2*)ppOut, a, b, p);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte ImTriangleContainsPointNative(Vector2 a, Vector2 b, Vector2 c, Vector2 p)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<Vector2, Vector2, Vector2, Vector2, byte>)funcTable[766])(a, b, c, p);
			#else
			return (byte)((delegate* unmanaged[Cdecl]<Vector2, Vector2, Vector2, Vector2, byte>)funcTable[766])(a, b, c, p);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ImTriangleContainsPoint(Vector2 a, Vector2 b, Vector2 c, Vector2 p)
		{
			byte ret = ImTriangleContainsPointNative(a, b, c, p);
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ImTriangleClosestPointNative(Vector2* pOut, Vector2 a, Vector2 b, Vector2 c, Vector2 p)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<Vector2*, Vector2, Vector2, Vector2, Vector2, void>)funcTable[767])(pOut, a, b, c, p);
			#else
			((delegate* unmanaged[Cdecl]<nint, Vector2, Vector2, Vector2, Vector2, void>)funcTable[767])((nint)pOut, a, b, c, p);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 ImTriangleClosestPoint(Vector2 a, Vector2 b, Vector2 c, Vector2 p)
		{
			Vector2 ret;
			ImTriangleClosestPointNative(&ret, a, b, c, p);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImTriangleClosestPoint(Vector2* pOut, Vector2 a, Vector2 b, Vector2 c, Vector2 p)
		{
			ImTriangleClosestPointNative(pOut, a, b, c, p);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImTriangleClosestPoint(ref Vector2 pOut, Vector2 a, Vector2 b, Vector2 c, Vector2 p)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				ImTriangleClosestPointNative((Vector2*)ppOut, a, b, c, p);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ImTriangleBarycentricCoordsNative(Vector2 a, Vector2 b, Vector2 c, Vector2 p, float* outU, float* outV, float* outW)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<Vector2, Vector2, Vector2, Vector2, float*, float*, float*, void>)funcTable[768])(a, b, c, p, outU, outV, outW);
			#else
			((delegate* unmanaged[Cdecl]<Vector2, Vector2, Vector2, Vector2, nint, nint, nint, void>)funcTable[768])(a, b, c, p, (nint)outU, (nint)outV, (nint)outW);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImTriangleBarycentricCoords(Vector2 a, Vector2 b, Vector2 c, Vector2 p, float* outU, float* outV, float* outW)
		{
			ImTriangleBarycentricCoordsNative(a, b, c, p, outU, outV, outW);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImTriangleBarycentricCoords(Vector2 a, Vector2 b, Vector2 c, Vector2 p, ref float outU, float* outV, float* outW)
		{
			fixed (float* poutU = &outU)
			{
				ImTriangleBarycentricCoordsNative(a, b, c, p, (float*)poutU, outV, outW);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImTriangleBarycentricCoords(Vector2 a, Vector2 b, Vector2 c, Vector2 p, float* outU, ref float outV, float* outW)
		{
			fixed (float* poutV = &outV)
			{
				ImTriangleBarycentricCoordsNative(a, b, c, p, outU, (float*)poutV, outW);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImTriangleBarycentricCoords(Vector2 a, Vector2 b, Vector2 c, Vector2 p, ref float outU, ref float outV, float* outW)
		{
			fixed (float* poutU = &outU)
			{
				fixed (float* poutV = &outV)
				{
					ImTriangleBarycentricCoordsNative(a, b, c, p, (float*)poutU, (float*)poutV, outW);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImTriangleBarycentricCoords(Vector2 a, Vector2 b, Vector2 c, Vector2 p, float* outU, float* outV, ref float outW)
		{
			fixed (float* poutW = &outW)
			{
				ImTriangleBarycentricCoordsNative(a, b, c, p, outU, outV, (float*)poutW);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImTriangleBarycentricCoords(Vector2 a, Vector2 b, Vector2 c, Vector2 p, ref float outU, float* outV, ref float outW)
		{
			fixed (float* poutU = &outU)
			{
				fixed (float* poutW = &outW)
				{
					ImTriangleBarycentricCoordsNative(a, b, c, p, (float*)poutU, outV, (float*)poutW);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImTriangleBarycentricCoords(Vector2 a, Vector2 b, Vector2 c, Vector2 p, float* outU, ref float outV, ref float outW)
		{
			fixed (float* poutV = &outV)
			{
				fixed (float* poutW = &outW)
				{
					ImTriangleBarycentricCoordsNative(a, b, c, p, outU, (float*)poutV, (float*)poutW);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImTriangleBarycentricCoords(Vector2 a, Vector2 b, Vector2 c, Vector2 p, ref float outU, ref float outV, ref float outW)
		{
			fixed (float* poutU = &outU)
			{
				fixed (float* poutV = &outV)
				{
					fixed (float* poutW = &outW)
					{
						ImTriangleBarycentricCoordsNative(a, b, c, p, (float*)poutU, (float*)poutV, (float*)poutW);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static float ImTriangleAreaNative(Vector2 a, Vector2 b, Vector2 c)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<Vector2, Vector2, Vector2, float>)funcTable[769])(a, b, c);
			#else
			return (float)((delegate* unmanaged[Cdecl]<Vector2, Vector2, Vector2, float>)funcTable[769])(a, b, c);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float ImTriangleArea(Vector2 a, Vector2 b, Vector2 c)
		{
			float ret = ImTriangleAreaNative(a, b, c);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImGuiDir ImGetDirQuadrantFromDeltaNative(float dx, float dy)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<float, float, ImGuiDir>)funcTable[770])(dx, dy);
			#else
			return (ImGuiDir)((delegate* unmanaged[Cdecl]<float, float, ImGuiDir>)funcTable[770])(dx, dy);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImGuiDir ImGetDirQuadrantFromDelta(float dx, float dy)
		{
			ImGuiDir ret = ImGetDirQuadrantFromDeltaNative(dx, dy);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImVec1* ImVec1Native()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImVec1*>)funcTable[771])();
			#else
			return (ImVec1*)((delegate* unmanaged[Cdecl]<nint>)funcTable[771])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImVec1Ptr ImVec1()
		{
			ImVec1Ptr ret = ImVec1Native();
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImVec1* ImVec1Native(float x)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<float, ImVec1*>)funcTable[772])(x);
			#else
			return (ImVec1*)((delegate* unmanaged[Cdecl]<float, nint>)funcTable[772])(x);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImVec1Ptr ImVec1(float x)
		{
			ImVec1Ptr ret = ImVec1Native(x);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImVec2Ih* ImVec2ihNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImVec2Ih*>)funcTable[773])();
			#else
			return (ImVec2Ih*)((delegate* unmanaged[Cdecl]<nint>)funcTable[773])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImVec2IhPtr ImVec2ih()
		{
			ImVec2IhPtr ret = ImVec2ihNative();
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImVec2Ih* ImVec2ihNative(short x, short y)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<short, short, ImVec2Ih*>)funcTable[774])(x, y);
			#else
			return (ImVec2Ih*)((delegate* unmanaged[Cdecl]<short, short, nint>)funcTable[774])(x, y);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImVec2IhPtr ImVec2ih(short x, short y)
		{
			ImVec2IhPtr ret = ImVec2ihNative(x, y);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImVec2Ih* ImVec2ihNative(Vector2 rhs)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<Vector2, ImVec2Ih*>)funcTable[775])(rhs);
			#else
			return (ImVec2Ih*)((delegate* unmanaged[Cdecl]<Vector2, nint>)funcTable[775])(rhs);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImVec2IhPtr ImVec2ih(Vector2 rhs)
		{
			ImVec2IhPtr ret = ImVec2ihNative(rhs);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImRect* ImRectNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImRect*>)funcTable[776])();
			#else
			return (ImRect*)((delegate* unmanaged[Cdecl]<nint>)funcTable[776])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImRectPtr ImRect()
		{
			ImRectPtr ret = ImRectNative();
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImRect* ImRectNative(Vector2 min, Vector2 max)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<Vector2, Vector2, ImRect*>)funcTable[777])(min, max);
			#else
			return (ImRect*)((delegate* unmanaged[Cdecl]<Vector2, Vector2, nint>)funcTable[777])(min, max);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImRectPtr ImRect(Vector2 min, Vector2 max)
		{
			ImRectPtr ret = ImRectNative(min, max);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImRect* ImRectNative(Vector4 v)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<Vector4, ImRect*>)funcTable[778])(v);
			#else
			return (ImRect*)((delegate* unmanaged[Cdecl]<Vector4, nint>)funcTable[778])(v);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImRectPtr ImRect(Vector4 v)
		{
			ImRectPtr ret = ImRectNative(v);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImRect* ImRectNative(float x1, float y1, float x2, float y2)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<float, float, float, float, ImRect*>)funcTable[779])(x1, y1, x2, y2);
			#else
			return (ImRect*)((delegate* unmanaged[Cdecl]<float, float, float, float, nint>)funcTable[779])(x1, y1, x2, y2);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImRectPtr ImRect(float x1, float y1, float x2, float y2)
		{
			ImRectPtr ret = ImRectNative(x1, y1, x2, y2);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void GetCenterNative(Vector2* pOut, ImRect* self)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<Vector2*, ImRect*, void>)funcTable[780])(pOut, self);
			#else
			((delegate* unmanaged[Cdecl]<nint, nint, void>)funcTable[780])((nint)pOut, (nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 GetCenter(ImRectPtr self)
		{
			Vector2 ret;
			GetCenterNative(&ret, self);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void GetCenter(Vector2* pOut, ImRectPtr self)
		{
			GetCenterNative(pOut, self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void GetCenter(ref Vector2 pOut, ImRectPtr self)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				GetCenterNative((Vector2*)ppOut, self);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 GetCenter(ref ImRect self)
		{
			fixed (ImRect* pself = &self)
			{
				Vector2 ret;
				GetCenterNative(&ret, (ImRect*)pself);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void GetCenter(Vector2* pOut, ref ImRect self)
		{
			fixed (ImRect* pself = &self)
			{
				GetCenterNative(pOut, (ImRect*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void GetCenter(ref Vector2 pOut, ref ImRect self)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				fixed (ImRect* pself = &self)
				{
					GetCenterNative((Vector2*)ppOut, (ImRect*)pself);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void GetSizeNative(Vector2* pOut, ImRect* self)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<Vector2*, ImRect*, void>)funcTable[781])(pOut, self);
			#else
			((delegate* unmanaged[Cdecl]<nint, nint, void>)funcTable[781])((nint)pOut, (nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 GetSize(ImRectPtr self)
		{
			Vector2 ret;
			GetSizeNative(&ret, self);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void GetSize(Vector2* pOut, ImRectPtr self)
		{
			GetSizeNative(pOut, self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void GetSize(ref Vector2 pOut, ImRectPtr self)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				GetSizeNative((Vector2*)ppOut, self);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 GetSize(ref ImRect self)
		{
			fixed (ImRect* pself = &self)
			{
				Vector2 ret;
				GetSizeNative(&ret, (ImRect*)pself);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void GetSize(Vector2* pOut, ref ImRect self)
		{
			fixed (ImRect* pself = &self)
			{
				GetSizeNative(pOut, (ImRect*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void GetSize(ref Vector2 pOut, ref ImRect self)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				fixed (ImRect* pself = &self)
				{
					GetSizeNative((Vector2*)ppOut, (ImRect*)pself);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static float GetWidthNative(ImRect* self)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImRect*, float>)funcTable[782])(self);
			#else
			return (float)((delegate* unmanaged[Cdecl]<nint, float>)funcTable[782])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float GetWidth(ImRectPtr self)
		{
			float ret = GetWidthNative(self);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float GetWidth(ref ImRect self)
		{
			fixed (ImRect* pself = &self)
			{
				float ret = GetWidthNative((ImRect*)pself);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static float GetHeightNative(ImRect* self)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImRect*, float>)funcTable[783])(self);
			#else
			return (float)((delegate* unmanaged[Cdecl]<nint, float>)funcTable[783])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float GetHeight(ImRectPtr self)
		{
			float ret = GetHeightNative(self);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float GetHeight(ref ImRect self)
		{
			fixed (ImRect* pself = &self)
			{
				float ret = GetHeightNative((ImRect*)pself);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static float GetAreaNative(ImRect* self)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImRect*, float>)funcTable[784])(self);
			#else
			return (float)((delegate* unmanaged[Cdecl]<nint, float>)funcTable[784])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float GetArea(ImRectPtr self)
		{
			float ret = GetAreaNative(self);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float GetArea(ref ImRect self)
		{
			fixed (ImRect* pself = &self)
			{
				float ret = GetAreaNative((ImRect*)pself);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void GetTLNative(Vector2* pOut, ImRect* self)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<Vector2*, ImRect*, void>)funcTable[785])(pOut, self);
			#else
			((delegate* unmanaged[Cdecl]<nint, nint, void>)funcTable[785])((nint)pOut, (nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 GetTL(ImRectPtr self)
		{
			Vector2 ret;
			GetTLNative(&ret, self);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void GetTL(Vector2* pOut, ImRectPtr self)
		{
			GetTLNative(pOut, self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void GetTL(ref Vector2 pOut, ImRectPtr self)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				GetTLNative((Vector2*)ppOut, self);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 GetTL(ref ImRect self)
		{
			fixed (ImRect* pself = &self)
			{
				Vector2 ret;
				GetTLNative(&ret, (ImRect*)pself);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void GetTL(Vector2* pOut, ref ImRect self)
		{
			fixed (ImRect* pself = &self)
			{
				GetTLNative(pOut, (ImRect*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void GetTL(ref Vector2 pOut, ref ImRect self)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				fixed (ImRect* pself = &self)
				{
					GetTLNative((Vector2*)ppOut, (ImRect*)pself);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void GetTRNative(Vector2* pOut, ImRect* self)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<Vector2*, ImRect*, void>)funcTable[786])(pOut, self);
			#else
			((delegate* unmanaged[Cdecl]<nint, nint, void>)funcTable[786])((nint)pOut, (nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 GetTR(ImRectPtr self)
		{
			Vector2 ret;
			GetTRNative(&ret, self);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void GetTR(Vector2* pOut, ImRectPtr self)
		{
			GetTRNative(pOut, self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void GetTR(ref Vector2 pOut, ImRectPtr self)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				GetTRNative((Vector2*)ppOut, self);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 GetTR(ref ImRect self)
		{
			fixed (ImRect* pself = &self)
			{
				Vector2 ret;
				GetTRNative(&ret, (ImRect*)pself);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void GetTR(Vector2* pOut, ref ImRect self)
		{
			fixed (ImRect* pself = &self)
			{
				GetTRNative(pOut, (ImRect*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void GetTR(ref Vector2 pOut, ref ImRect self)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				fixed (ImRect* pself = &self)
				{
					GetTRNative((Vector2*)ppOut, (ImRect*)pself);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void GetBLNative(Vector2* pOut, ImRect* self)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<Vector2*, ImRect*, void>)funcTable[787])(pOut, self);
			#else
			((delegate* unmanaged[Cdecl]<nint, nint, void>)funcTable[787])((nint)pOut, (nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 GetBL(ImRectPtr self)
		{
			Vector2 ret;
			GetBLNative(&ret, self);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void GetBL(Vector2* pOut, ImRectPtr self)
		{
			GetBLNative(pOut, self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void GetBL(ref Vector2 pOut, ImRectPtr self)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				GetBLNative((Vector2*)ppOut, self);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 GetBL(ref ImRect self)
		{
			fixed (ImRect* pself = &self)
			{
				Vector2 ret;
				GetBLNative(&ret, (ImRect*)pself);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void GetBL(Vector2* pOut, ref ImRect self)
		{
			fixed (ImRect* pself = &self)
			{
				GetBLNative(pOut, (ImRect*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void GetBL(ref Vector2 pOut, ref ImRect self)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				fixed (ImRect* pself = &self)
				{
					GetBLNative((Vector2*)ppOut, (ImRect*)pself);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void GetBRNative(Vector2* pOut, ImRect* self)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<Vector2*, ImRect*, void>)funcTable[788])(pOut, self);
			#else
			((delegate* unmanaged[Cdecl]<nint, nint, void>)funcTable[788])((nint)pOut, (nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 GetBR(ImRectPtr self)
		{
			Vector2 ret;
			GetBRNative(&ret, self);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void GetBR(Vector2* pOut, ImRectPtr self)
		{
			GetBRNative(pOut, self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void GetBR(ref Vector2 pOut, ImRectPtr self)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				GetBRNative((Vector2*)ppOut, self);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector2 GetBR(ref ImRect self)
		{
			fixed (ImRect* pself = &self)
			{
				Vector2 ret;
				GetBRNative(&ret, (ImRect*)pself);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void GetBR(Vector2* pOut, ref ImRect self)
		{
			fixed (ImRect* pself = &self)
			{
				GetBRNative(pOut, (ImRect*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void GetBR(ref Vector2 pOut, ref ImRect self)
		{
			fixed (Vector2* ppOut = &pOut)
			{
				fixed (ImRect* pself = &self)
				{
					GetBRNative((Vector2*)ppOut, (ImRect*)pself);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte ContainsNative(ImRect* self, Vector2 p)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImRect*, Vector2, byte>)funcTable[789])(self, p);
			#else
			return (byte)((delegate* unmanaged[Cdecl]<nint, Vector2, byte>)funcTable[789])((nint)self, p);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Contains(ImRectPtr self, Vector2 p)
		{
			byte ret = ContainsNative(self, p);
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Contains(ref ImRect self, Vector2 p)
		{
			fixed (ImRect* pself = &self)
			{
				byte ret = ContainsNative((ImRect*)pself, p);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte ContainsNative(ImRect* self, ImRect r)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImRect*, ImRect, byte>)funcTable[790])(self, r);
			#else
			return (byte)((delegate* unmanaged[Cdecl]<nint, ImRect, byte>)funcTable[790])((nint)self, r);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Contains(ImRectPtr self, ImRect r)
		{
			byte ret = ContainsNative(self, r);
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Contains(ref ImRect self, ImRect r)
		{
			fixed (ImRect* pself = &self)
			{
				byte ret = ContainsNative((ImRect*)pself, r);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte OverlapsNative(ImRect* self, ImRect r)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImRect*, ImRect, byte>)funcTable[791])(self, r);
			#else
			return (byte)((delegate* unmanaged[Cdecl]<nint, ImRect, byte>)funcTable[791])((nint)self, r);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Overlaps(ImRectPtr self, ImRect r)
		{
			byte ret = OverlapsNative(self, r);
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Overlaps(ref ImRect self, ImRect r)
		{
			fixed (ImRect* pself = &self)
			{
				byte ret = OverlapsNative((ImRect*)pself, r);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void AddNative(ImRect* self, Vector2 p)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImRect*, Vector2, void>)funcTable[792])(self, p);
			#else
			((delegate* unmanaged[Cdecl]<nint, Vector2, void>)funcTable[792])((nint)self, p);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Add(ImRectPtr self, Vector2 p)
		{
			AddNative(self, p);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Add(ref ImRect self, Vector2 p)
		{
			fixed (ImRect* pself = &self)
			{
				AddNative((ImRect*)pself, p);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void AddNative(ImRect* self, ImRect r)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImRect*, ImRect, void>)funcTable[793])(self, r);
			#else
			((delegate* unmanaged[Cdecl]<nint, ImRect, void>)funcTable[793])((nint)self, r);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Add(ImRectPtr self, ImRect r)
		{
			AddNative(self, r);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Add(ref ImRect self, ImRect r)
		{
			fixed (ImRect* pself = &self)
			{
				AddNative((ImRect*)pself, r);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ExpandNative(ImRect* self, float amount)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImRect*, float, void>)funcTable[794])(self, amount);
			#else
			((delegate* unmanaged[Cdecl]<nint, float, void>)funcTable[794])((nint)self, amount);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Expand(ImRectPtr self, float amount)
		{
			ExpandNative(self, amount);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Expand(ref ImRect self, float amount)
		{
			fixed (ImRect* pself = &self)
			{
				ExpandNative((ImRect*)pself, amount);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ExpandNative(ImRect* self, Vector2 amount)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImRect*, Vector2, void>)funcTable[795])(self, amount);
			#else
			((delegate* unmanaged[Cdecl]<nint, Vector2, void>)funcTable[795])((nint)self, amount);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Expand(ImRectPtr self, Vector2 amount)
		{
			ExpandNative(self, amount);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Expand(ref ImRect self, Vector2 amount)
		{
			fixed (ImRect* pself = &self)
			{
				ExpandNative((ImRect*)pself, amount);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void TranslateNative(ImRect* self, Vector2 d)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImRect*, Vector2, void>)funcTable[796])(self, d);
			#else
			((delegate* unmanaged[Cdecl]<nint, Vector2, void>)funcTable[796])((nint)self, d);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Translate(ImRectPtr self, Vector2 d)
		{
			TranslateNative(self, d);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Translate(ref ImRect self, Vector2 d)
		{
			fixed (ImRect* pself = &self)
			{
				TranslateNative((ImRect*)pself, d);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void TranslateXNative(ImRect* self, float dx)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImRect*, float, void>)funcTable[797])(self, dx);
			#else
			((delegate* unmanaged[Cdecl]<nint, float, void>)funcTable[797])((nint)self, dx);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TranslateX(ImRectPtr self, float dx)
		{
			TranslateXNative(self, dx);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TranslateX(ref ImRect self, float dx)
		{
			fixed (ImRect* pself = &self)
			{
				TranslateXNative((ImRect*)pself, dx);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void TranslateYNative(ImRect* self, float dy)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImRect*, float, void>)funcTable[798])(self, dy);
			#else
			((delegate* unmanaged[Cdecl]<nint, float, void>)funcTable[798])((nint)self, dy);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TranslateY(ImRectPtr self, float dy)
		{
			TranslateYNative(self, dy);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void TranslateY(ref ImRect self, float dy)
		{
			fixed (ImRect* pself = &self)
			{
				TranslateYNative((ImRect*)pself, dy);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ClipWithNative(ImRect* self, ImRect r)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImRect*, ImRect, void>)funcTable[799])(self, r);
			#else
			((delegate* unmanaged[Cdecl]<nint, ImRect, void>)funcTable[799])((nint)self, r);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ClipWith(ImRectPtr self, ImRect r)
		{
			ClipWithNative(self, r);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ClipWith(ref ImRect self, ImRect r)
		{
			fixed (ImRect* pself = &self)
			{
				ClipWithNative((ImRect*)pself, r);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ClipWithFullNative(ImRect* self, ImRect r)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImRect*, ImRect, void>)funcTable[800])(self, r);
			#else
			((delegate* unmanaged[Cdecl]<nint, ImRect, void>)funcTable[800])((nint)self, r);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ClipWithFull(ImRectPtr self, ImRect r)
		{
			ClipWithFullNative(self, r);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ClipWithFull(ref ImRect self, ImRect r)
		{
			fixed (ImRect* pself = &self)
			{
				ClipWithFullNative((ImRect*)pself, r);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void FloorNative(ImRect* self)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImRect*, void>)funcTable[801])(self);
			#else
			((delegate* unmanaged[Cdecl]<nint, void>)funcTable[801])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Floor(ImRectPtr self)
		{
			FloorNative(self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Floor(ref ImRect self)
		{
			fixed (ImRect* pself = &self)
			{
				FloorNative((ImRect*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte IsInvertedNative(ImRect* self)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImRect*, byte>)funcTable[802])(self);
			#else
			return (byte)((delegate* unmanaged[Cdecl]<nint, byte>)funcTable[802])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool IsInverted(ImRectPtr self)
		{
			byte ret = IsInvertedNative(self);
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool IsInverted(ref ImRect self)
		{
			fixed (ImRect* pself = &self)
			{
				byte ret = IsInvertedNative((ImRect*)pself);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ToVec4Native(Vector4* pOut, ImRect* self)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<Vector4*, ImRect*, void>)funcTable[803])(pOut, self);
			#else
			((delegate* unmanaged[Cdecl]<nint, nint, void>)funcTable[803])((nint)pOut, (nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector4 ToVec4(ImRectPtr self)
		{
			Vector4 ret;
			ToVec4Native(&ret, self);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ToVec4(Vector4* pOut, ImRectPtr self)
		{
			ToVec4Native(pOut, self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ToVec4(ref Vector4 pOut, ImRectPtr self)
		{
			fixed (Vector4* ppOut = &pOut)
			{
				ToVec4Native((Vector4*)ppOut, self);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static Vector4 ToVec4(ref ImRect self)
		{
			fixed (ImRect* pself = &self)
			{
				Vector4 ret;
				ToVec4Native(&ret, (ImRect*)pself);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ToVec4(Vector4* pOut, ref ImRect self)
		{
			fixed (ImRect* pself = &self)
			{
				ToVec4Native(pOut, (ImRect*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ToVec4(ref Vector4 pOut, ref ImRect self)
		{
			fixed (Vector4* ppOut = &pOut)
			{
				fixed (ImRect* pself = &self)
				{
					ToVec4Native((Vector4*)ppOut, (ImRect*)pself);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte ImBitArrayTestBitNative(uint* arr, int n)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<uint*, int, byte>)funcTable[804])(arr, n);
			#else
			return (byte)((delegate* unmanaged[Cdecl]<nint, int, byte>)funcTable[804])((nint)arr, n);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ImBitArrayTestBit(uint* arr, int n)
		{
			byte ret = ImBitArrayTestBitNative(arr, n);
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ImBitArrayTestBit(ref uint arr, int n)
		{
			fixed (uint* parr = &arr)
			{
				byte ret = ImBitArrayTestBitNative((uint*)parr, n);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ImBitArrayClearBitNative(uint* arr, int n)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<uint*, int, void>)funcTable[805])(arr, n);
			#else
			((delegate* unmanaged[Cdecl]<nint, int, void>)funcTable[805])((nint)arr, n);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImBitArrayClearBit(uint* arr, int n)
		{
			ImBitArrayClearBitNative(arr, n);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImBitArrayClearBit(ref uint arr, int n)
		{
			fixed (uint* parr = &arr)
			{
				ImBitArrayClearBitNative((uint*)parr, n);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ImBitArraySetBitNative(uint* arr, int n)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<uint*, int, void>)funcTable[806])(arr, n);
			#else
			((delegate* unmanaged[Cdecl]<nint, int, void>)funcTable[806])((nint)arr, n);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImBitArraySetBit(uint* arr, int n)
		{
			ImBitArraySetBitNative(arr, n);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImBitArraySetBit(ref uint arr, int n)
		{
			fixed (uint* parr = &arr)
			{
				ImBitArraySetBitNative((uint*)parr, n);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ImBitArraySetBitRangeNative(uint* arr, int n, int n2)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<uint*, int, int, void>)funcTable[807])(arr, n, n2);
			#else
			((delegate* unmanaged[Cdecl]<nint, int, int, void>)funcTable[807])((nint)arr, n, n2);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImBitArraySetBitRange(uint* arr, int n, int n2)
		{
			ImBitArraySetBitRangeNative(arr, n, n2);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImBitArraySetBitRange(ref uint arr, int n, int n2)
		{
			fixed (uint* parr = &arr)
			{
				ImBitArraySetBitRangeNative((uint*)parr, n, n2);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void CreateNative(ImBitVector* self, int sz)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImBitVector*, int, void>)funcTable[808])(self, sz);
			#else
			((delegate* unmanaged[Cdecl]<nint, int, void>)funcTable[808])((nint)self, sz);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Create(ImBitVectorPtr self, int sz)
		{
			CreateNative(self, sz);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Create(ref ImBitVector self, int sz)
		{
			fixed (ImBitVector* pself = &self)
			{
				CreateNative((ImBitVector*)pself, sz);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ClearNative(ImBitVector* self)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImBitVector*, void>)funcTable[809])(self);
			#else
			((delegate* unmanaged[Cdecl]<nint, void>)funcTable[809])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Clear(ImBitVectorPtr self)
		{
			ClearNative(self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Clear(ref ImBitVector self)
		{
			fixed (ImBitVector* pself = &self)
			{
				ClearNative((ImBitVector*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte TestBitNative(ImBitVector* self, int n)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImBitVector*, int, byte>)funcTable[810])(self, n);
			#else
			return (byte)((delegate* unmanaged[Cdecl]<nint, int, byte>)funcTable[810])((nint)self, n);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool TestBit(ImBitVectorPtr self, int n)
		{
			byte ret = TestBitNative(self, n);
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool TestBit(ref ImBitVector self, int n)
		{
			fixed (ImBitVector* pself = &self)
			{
				byte ret = TestBitNative((ImBitVector*)pself, n);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SetBitNative(ImBitVector* self, int n)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImBitVector*, int, void>)funcTable[811])(self, n);
			#else
			((delegate* unmanaged[Cdecl]<nint, int, void>)funcTable[811])((nint)self, n);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetBit(ImBitVectorPtr self, int n)
		{
			SetBitNative(self, n);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetBit(ref ImBitVector self, int n)
		{
			fixed (ImBitVector* pself = &self)
			{
				SetBitNative((ImBitVector*)pself, n);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ClearBitNative(ImBitVector* self, int n)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImBitVector*, int, void>)funcTable[812])(self, n);
			#else
			((delegate* unmanaged[Cdecl]<nint, int, void>)funcTable[812])((nint)self, n);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ClearBit(ImBitVectorPtr self, int n)
		{
			ClearBitNative(self, n);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ClearBit(ref ImBitVector self, int n)
		{
			fixed (ImBitVector* pself = &self)
			{
				ClearBitNative((ImBitVector*)pself, n);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImDrawListSharedData* ImDrawListSharedDataNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImDrawListSharedData*>)funcTable[813])();
			#else
			return (ImDrawListSharedData*)((delegate* unmanaged[Cdecl]<nint>)funcTable[813])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImDrawListSharedDataPtr ImDrawListSharedData()
		{
			ImDrawListSharedDataPtr ret = ImDrawListSharedDataNative();
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SetCircleTessellationMaxErrorNative(ImDrawListSharedData* self, float maxError)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImDrawListSharedData*, float, void>)funcTable[814])(self, maxError);
			#else
			((delegate* unmanaged[Cdecl]<nint, float, void>)funcTable[814])((nint)self, maxError);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetCircleTessellationMaxError(ImDrawListSharedDataPtr self, float maxError)
		{
			SetCircleTessellationMaxErrorNative(self, maxError);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetCircleTessellationMaxError(ref ImDrawListSharedData self, float maxError)
		{
			fixed (ImDrawListSharedData* pself = &self)
			{
				SetCircleTessellationMaxErrorNative((ImDrawListSharedData*)pself, maxError);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ClearNative(ImDrawDataBuilder* self)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImDrawDataBuilder*, void>)funcTable[815])(self);
			#else
			((delegate* unmanaged[Cdecl]<nint, void>)funcTable[815])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Clear(ImDrawDataBuilderPtr self)
		{
			ClearNative(self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Clear(ref ImDrawDataBuilder self)
		{
			fixed (ImDrawDataBuilder* pself = &self)
			{
				ClearNative((ImDrawDataBuilder*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ClearFreeMemoryNative(ImDrawDataBuilder* self)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImDrawDataBuilder*, void>)funcTable[816])(self);
			#else
			((delegate* unmanaged[Cdecl]<nint, void>)funcTable[816])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ClearFreeMemory(ImDrawDataBuilderPtr self)
		{
			ClearFreeMemoryNative(self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ClearFreeMemory(ref ImDrawDataBuilder self)
		{
			fixed (ImDrawDataBuilder* pself = &self)
			{
				ClearFreeMemoryNative((ImDrawDataBuilder*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static int GetDrawListCountNative(ImDrawDataBuilder* self)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImDrawDataBuilder*, int>)funcTable[817])(self);
			#else
			return (int)((delegate* unmanaged[Cdecl]<nint, int>)funcTable[817])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int GetDrawListCount(ImDrawDataBuilderPtr self)
		{
			int ret = GetDrawListCountNative(self);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int GetDrawListCount(ref ImDrawDataBuilder self)
		{
			fixed (ImDrawDataBuilder* pself = &self)
			{
				int ret = GetDrawListCountNative((ImDrawDataBuilder*)pself);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void FlattenIntoSingleLayerNative(ImDrawDataBuilder* self)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImDrawDataBuilder*, void>)funcTable[818])(self);
			#else
			((delegate* unmanaged[Cdecl]<nint, void>)funcTable[818])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void FlattenIntoSingleLayer(ImDrawDataBuilderPtr self)
		{
			FlattenIntoSingleLayerNative(self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void FlattenIntoSingleLayer(ref ImDrawDataBuilder self)
		{
			fixed (ImDrawDataBuilder* pself = &self)
			{
				FlattenIntoSingleLayerNative((ImDrawDataBuilder*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImGuiStyleMod* ImGuiStyleModNative(ImGuiStyleVar idx, int v)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiStyleVar, int, ImGuiStyleMod*>)funcTable[819])(idx, v);
			#else
			return (ImGuiStyleMod*)((delegate* unmanaged[Cdecl]<ImGuiStyleVar, int, nint>)funcTable[819])(idx, v);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImGuiStyleModPtr ImGuiStyleMod(ImGuiStyleVar idx, int v)
		{
			ImGuiStyleModPtr ret = ImGuiStyleModNative(idx, v);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImGuiStyleMod* ImGuiStyleModNative(ImGuiStyleVar idx, float v)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiStyleVar, float, ImGuiStyleMod*>)funcTable[820])(idx, v);
			#else
			return (ImGuiStyleMod*)((delegate* unmanaged[Cdecl]<ImGuiStyleVar, float, nint>)funcTable[820])(idx, v);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImGuiStyleModPtr ImGuiStyleMod(ImGuiStyleVar idx, float v)
		{
			ImGuiStyleModPtr ret = ImGuiStyleModNative(idx, v);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImGuiStyleMod* ImGuiStyleModNative(ImGuiStyleVar idx, Vector2 v)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiStyleVar, Vector2, ImGuiStyleMod*>)funcTable[821])(idx, v);
			#else
			return (ImGuiStyleMod*)((delegate* unmanaged[Cdecl]<ImGuiStyleVar, Vector2, nint>)funcTable[821])(idx, v);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImGuiStyleModPtr ImGuiStyleMod(ImGuiStyleVar idx, Vector2 v)
		{
			ImGuiStyleModPtr ret = ImGuiStyleModNative(idx, v);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImGuiComboPreviewData* ImGuiComboPreviewDataNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiComboPreviewData*>)funcTable[822])();
			#else
			return (ImGuiComboPreviewData*)((delegate* unmanaged[Cdecl]<nint>)funcTable[822])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImGuiComboPreviewDataPtr ImGuiComboPreviewData()
		{
			ImGuiComboPreviewDataPtr ret = ImGuiComboPreviewDataNative();
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImGuiMenuColumns* ImGuiMenuColumnsNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiMenuColumns*>)funcTable[823])();
			#else
			return (ImGuiMenuColumns*)((delegate* unmanaged[Cdecl]<nint>)funcTable[823])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImGuiMenuColumnsPtr ImGuiMenuColumns()
		{
			ImGuiMenuColumnsPtr ret = ImGuiMenuColumnsNative();
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void UpdateNative(ImGuiMenuColumns* self, float spacing, byte windowReappearing)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImGuiMenuColumns*, float, byte, void>)funcTable[824])(self, spacing, windowReappearing);
			#else
			((delegate* unmanaged[Cdecl]<nint, float, byte, void>)funcTable[824])((nint)self, spacing, windowReappearing);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Update(ImGuiMenuColumnsPtr self, float spacing, bool windowReappearing)
		{
			UpdateNative(self, spacing, windowReappearing ? (byte)1 : (byte)0);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Update(ref ImGuiMenuColumns self, float spacing, bool windowReappearing)
		{
			fixed (ImGuiMenuColumns* pself = &self)
			{
				UpdateNative((ImGuiMenuColumns*)pself, spacing, windowReappearing ? (byte)1 : (byte)0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static float DeclColumnsNative(ImGuiMenuColumns* self, float wIcon, float wLabel, float wShortcut, float wMark)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiMenuColumns*, float, float, float, float, float>)funcTable[825])(self, wIcon, wLabel, wShortcut, wMark);
			#else
			return (float)((delegate* unmanaged[Cdecl]<nint, float, float, float, float, float>)funcTable[825])((nint)self, wIcon, wLabel, wShortcut, wMark);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float DeclColumns(ImGuiMenuColumnsPtr self, float wIcon, float wLabel, float wShortcut, float wMark)
		{
			float ret = DeclColumnsNative(self, wIcon, wLabel, wShortcut, wMark);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float DeclColumns(ref ImGuiMenuColumns self, float wIcon, float wLabel, float wShortcut, float wMark)
		{
			fixed (ImGuiMenuColumns* pself = &self)
			{
				float ret = DeclColumnsNative((ImGuiMenuColumns*)pself, wIcon, wLabel, wShortcut, wMark);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void CalcNextTotalWidthNative(ImGuiMenuColumns* self, byte updateOffsets)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImGuiMenuColumns*, byte, void>)funcTable[826])(self, updateOffsets);
			#else
			((delegate* unmanaged[Cdecl]<nint, byte, void>)funcTable[826])((nint)self, updateOffsets);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void CalcNextTotalWidth(ImGuiMenuColumnsPtr self, bool updateOffsets)
		{
			CalcNextTotalWidthNative(self, updateOffsets ? (byte)1 : (byte)0);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void CalcNextTotalWidth(ref ImGuiMenuColumns self, bool updateOffsets)
		{
			fixed (ImGuiMenuColumns* pself = &self)
			{
				CalcNextTotalWidthNative((ImGuiMenuColumns*)pself, updateOffsets ? (byte)1 : (byte)0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImGuiInputTextState* ImGuiInputTextStateNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiInputTextState*>)funcTable[827])();
			#else
			return (ImGuiInputTextState*)((delegate* unmanaged[Cdecl]<nint>)funcTable[827])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImGuiInputTextStatePtr ImGuiInputTextState()
		{
			ImGuiInputTextStatePtr ret = ImGuiInputTextStateNative();
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ClearTextNative(ImGuiInputTextState* self)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImGuiInputTextState*, void>)funcTable[828])(self);
			#else
			((delegate* unmanaged[Cdecl]<nint, void>)funcTable[828])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ClearText(ImGuiInputTextStatePtr self)
		{
			ClearTextNative(self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ClearText(ref ImGuiInputTextState self)
		{
			fixed (ImGuiInputTextState* pself = &self)
			{
				ClearTextNative((ImGuiInputTextState*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ClearFreeMemoryNative(ImGuiInputTextState* self)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImGuiInputTextState*, void>)funcTable[829])(self);
			#else
			((delegate* unmanaged[Cdecl]<nint, void>)funcTable[829])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ClearFreeMemory(ImGuiInputTextStatePtr self)
		{
			ClearFreeMemoryNative(self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ClearFreeMemory(ref ImGuiInputTextState self)
		{
			fixed (ImGuiInputTextState* pself = &self)
			{
				ClearFreeMemoryNative((ImGuiInputTextState*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static int GetUndoAvailCountNative(ImGuiInputTextState* self)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiInputTextState*, int>)funcTable[830])(self);
			#else
			return (int)((delegate* unmanaged[Cdecl]<nint, int>)funcTable[830])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int GetUndoAvailCount(ImGuiInputTextStatePtr self)
		{
			int ret = GetUndoAvailCountNative(self);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int GetUndoAvailCount(ref ImGuiInputTextState self)
		{
			fixed (ImGuiInputTextState* pself = &self)
			{
				int ret = GetUndoAvailCountNative((ImGuiInputTextState*)pself);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static int GetRedoAvailCountNative(ImGuiInputTextState* self)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiInputTextState*, int>)funcTable[831])(self);
			#else
			return (int)((delegate* unmanaged[Cdecl]<nint, int>)funcTable[831])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int GetRedoAvailCount(ImGuiInputTextStatePtr self)
		{
			int ret = GetRedoAvailCountNative(self);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int GetRedoAvailCount(ref ImGuiInputTextState self)
		{
			fixed (ImGuiInputTextState* pself = &self)
			{
				int ret = GetRedoAvailCountNative((ImGuiInputTextState*)pself);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void OnKeyPressedNative(ImGuiInputTextState* self, int key)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImGuiInputTextState*, int, void>)funcTable[832])(self, key);
			#else
			((delegate* unmanaged[Cdecl]<nint, int, void>)funcTable[832])((nint)self, key);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void OnKeyPressed(ImGuiInputTextStatePtr self, int key)
		{
			OnKeyPressedNative(self, key);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void OnKeyPressed(ref ImGuiInputTextState self, int key)
		{
			fixed (ImGuiInputTextState* pself = &self)
			{
				OnKeyPressedNative((ImGuiInputTextState*)pself, key);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void CursorAnimResetNative(ImGuiInputTextState* self)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImGuiInputTextState*, void>)funcTable[833])(self);
			#else
			((delegate* unmanaged[Cdecl]<nint, void>)funcTable[833])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void CursorAnimReset(ImGuiInputTextStatePtr self)
		{
			CursorAnimResetNative(self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void CursorAnimReset(ref ImGuiInputTextState self)
		{
			fixed (ImGuiInputTextState* pself = &self)
			{
				CursorAnimResetNative((ImGuiInputTextState*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void CursorClampNative(ImGuiInputTextState* self)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImGuiInputTextState*, void>)funcTable[834])(self);
			#else
			((delegate* unmanaged[Cdecl]<nint, void>)funcTable[834])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void CursorClamp(ImGuiInputTextStatePtr self)
		{
			CursorClampNative(self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void CursorClamp(ref ImGuiInputTextState self)
		{
			fixed (ImGuiInputTextState* pself = &self)
			{
				CursorClampNative((ImGuiInputTextState*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte HasSelectionNative(ImGuiInputTextState* self)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiInputTextState*, byte>)funcTable[835])(self);
			#else
			return (byte)((delegate* unmanaged[Cdecl]<nint, byte>)funcTable[835])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool HasSelection(ImGuiInputTextStatePtr self)
		{
			byte ret = HasSelectionNative(self);
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool HasSelection(ref ImGuiInputTextState self)
		{
			fixed (ImGuiInputTextState* pself = &self)
			{
				byte ret = HasSelectionNative((ImGuiInputTextState*)pself);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ClearSelectionNative(ImGuiInputTextState* self)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImGuiInputTextState*, void>)funcTable[836])(self);
			#else
			((delegate* unmanaged[Cdecl]<nint, void>)funcTable[836])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ClearSelection(ImGuiInputTextStatePtr self)
		{
			ClearSelectionNative(self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ClearSelection(ref ImGuiInputTextState self)
		{
			fixed (ImGuiInputTextState* pself = &self)
			{
				ClearSelectionNative((ImGuiInputTextState*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static int GetCursorPosNative(ImGuiInputTextState* self)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiInputTextState*, int>)funcTable[837])(self);
			#else
			return (int)((delegate* unmanaged[Cdecl]<nint, int>)funcTable[837])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int GetCursorPos(ImGuiInputTextStatePtr self)
		{
			int ret = GetCursorPosNative(self);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int GetCursorPos(ref ImGuiInputTextState self)
		{
			fixed (ImGuiInputTextState* pself = &self)
			{
				int ret = GetCursorPosNative((ImGuiInputTextState*)pself);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static int GetSelectionStartNative(ImGuiInputTextState* self)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiInputTextState*, int>)funcTable[838])(self);
			#else
			return (int)((delegate* unmanaged[Cdecl]<nint, int>)funcTable[838])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int GetSelectionStart(ImGuiInputTextStatePtr self)
		{
			int ret = GetSelectionStartNative(self);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int GetSelectionStart(ref ImGuiInputTextState self)
		{
			fixed (ImGuiInputTextState* pself = &self)
			{
				int ret = GetSelectionStartNative((ImGuiInputTextState*)pself);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static int GetSelectionEndNative(ImGuiInputTextState* self)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiInputTextState*, int>)funcTable[839])(self);
			#else
			return (int)((delegate* unmanaged[Cdecl]<nint, int>)funcTable[839])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int GetSelectionEnd(ImGuiInputTextStatePtr self)
		{
			int ret = GetSelectionEndNative(self);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int GetSelectionEnd(ref ImGuiInputTextState self)
		{
			fixed (ImGuiInputTextState* pself = &self)
			{
				int ret = GetSelectionEndNative((ImGuiInputTextState*)pself);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SelectAllNative(ImGuiInputTextState* self)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImGuiInputTextState*, void>)funcTable[840])(self);
			#else
			((delegate* unmanaged[Cdecl]<nint, void>)funcTable[840])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SelectAll(ImGuiInputTextStatePtr self)
		{
			SelectAllNative(self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SelectAll(ref ImGuiInputTextState self)
		{
			fixed (ImGuiInputTextState* pself = &self)
			{
				SelectAllNative((ImGuiInputTextState*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImGuiPopupData* ImGuiPopupDataNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiPopupData*>)funcTable[841])();
			#else
			return (ImGuiPopupData*)((delegate* unmanaged[Cdecl]<nint>)funcTable[841])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImGuiPopupDataPtr ImGuiPopupData()
		{
			ImGuiPopupDataPtr ret = ImGuiPopupDataNative();
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImGuiNextWindowData* ImGuiNextWindowDataNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiNextWindowData*>)funcTable[842])();
			#else
			return (ImGuiNextWindowData*)((delegate* unmanaged[Cdecl]<nint>)funcTable[842])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImGuiNextWindowDataPtr ImGuiNextWindowData()
		{
			ImGuiNextWindowDataPtr ret = ImGuiNextWindowDataNative();
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ClearFlagsNative(ImGuiNextWindowData* self)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImGuiNextWindowData*, void>)funcTable[843])(self);
			#else
			((delegate* unmanaged[Cdecl]<nint, void>)funcTable[843])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ClearFlags(ImGuiNextWindowDataPtr self)
		{
			ClearFlagsNative(self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ClearFlags(ref ImGuiNextWindowData self)
		{
			fixed (ImGuiNextWindowData* pself = &self)
			{
				ClearFlagsNative((ImGuiNextWindowData*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImGuiNextItemData* ImGuiNextItemDataNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiNextItemData*>)funcTable[844])();
			#else
			return (ImGuiNextItemData*)((delegate* unmanaged[Cdecl]<nint>)funcTable[844])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImGuiNextItemDataPtr ImGuiNextItemData()
		{
			ImGuiNextItemDataPtr ret = ImGuiNextItemDataNative();
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ClearFlagsNative(ImGuiNextItemData* self)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImGuiNextItemData*, void>)funcTable[845])(self);
			#else
			((delegate* unmanaged[Cdecl]<nint, void>)funcTable[845])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ClearFlags(ImGuiNextItemDataPtr self)
		{
			ClearFlagsNative(self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ClearFlags(ref ImGuiNextItemData self)
		{
			fixed (ImGuiNextItemData* pself = &self)
			{
				ClearFlagsNative((ImGuiNextItemData*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImGuiLastItemData* ImGuiLastItemDataNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiLastItemData*>)funcTable[846])();
			#else
			return (ImGuiLastItemData*)((delegate* unmanaged[Cdecl]<nint>)funcTable[846])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImGuiLastItemDataPtr ImGuiLastItemData()
		{
			ImGuiLastItemDataPtr ret = ImGuiLastItemDataNative();
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImGuiPtrOrIndex* ImGuiPtrOrIndexNative(void* ptr)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<void*, ImGuiPtrOrIndex*>)funcTable[847])(ptr);
			#else
			return (ImGuiPtrOrIndex*)((delegate* unmanaged[Cdecl]<nint, nint>)funcTable[847])((nint)ptr);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImGuiPtrOrIndexPtr ImGuiPtrOrIndex(void* ptr)
		{
			ImGuiPtrOrIndexPtr ret = ImGuiPtrOrIndexNative(ptr);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImGuiPtrOrIndex* ImGuiPtrOrIndexNative(int index)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<int, ImGuiPtrOrIndex*>)funcTable[848])(index);
			#else
			return (ImGuiPtrOrIndex*)((delegate* unmanaged[Cdecl]<int, nint>)funcTable[848])(index);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImGuiPtrOrIndexPtr ImGuiPtrOrIndex(int index)
		{
			ImGuiPtrOrIndexPtr ret = ImGuiPtrOrIndexNative(index);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImGuiInputEvent* ImGuiInputEventNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiInputEvent*>)funcTable[849])();
			#else
			return (ImGuiInputEvent*)((delegate* unmanaged[Cdecl]<nint>)funcTable[849])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImGuiInputEventPtr ImGuiInputEvent()
		{
			ImGuiInputEventPtr ret = ImGuiInputEventNative();
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImGuiListClipperRange FromIndicesNative(int min, int max)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<int, int, ImGuiListClipperRange>)funcTable[850])(min, max);
			#else
			return (ImGuiListClipperRange)((delegate* unmanaged[Cdecl]<int, int, ImGuiListClipperRange>)funcTable[850])(min, max);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImGuiListClipperRange FromIndices(int min, int max)
		{
			ImGuiListClipperRange ret = FromIndicesNative(min, max);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImGuiListClipperRange FromPositionsNative(float y1, float y2, int offMin, int offMax)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<float, float, int, int, ImGuiListClipperRange>)funcTable[851])(y1, y2, offMin, offMax);
			#else
			return (ImGuiListClipperRange)((delegate* unmanaged[Cdecl]<float, float, int, int, ImGuiListClipperRange>)funcTable[851])(y1, y2, offMin, offMax);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImGuiListClipperRange FromPositions(float y1, float y2, int offMin, int offMax)
		{
			ImGuiListClipperRange ret = FromPositionsNative(y1, y2, offMin, offMax);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImGuiListClipperData* ImGuiListClipperDataNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiListClipperData*>)funcTable[852])();
			#else
			return (ImGuiListClipperData*)((delegate* unmanaged[Cdecl]<nint>)funcTable[852])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImGuiListClipperDataPtr ImGuiListClipperData()
		{
			ImGuiListClipperDataPtr ret = ImGuiListClipperDataNative();
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ResetNative(ImGuiListClipperData* self, ImGuiListClipper* clipper)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImGuiListClipperData*, ImGuiListClipper*, void>)funcTable[853])(self, clipper);
			#else
			((delegate* unmanaged[Cdecl]<nint, nint, void>)funcTable[853])((nint)self, (nint)clipper);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Reset(ImGuiListClipperDataPtr self, ImGuiListClipperPtr clipper)
		{
			ResetNative(self, clipper);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Reset(ref ImGuiListClipperData self, ImGuiListClipperPtr clipper)
		{
			fixed (ImGuiListClipperData* pself = &self)
			{
				ResetNative((ImGuiListClipperData*)pself, clipper);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Reset(ImGuiListClipperDataPtr self, ref ImGuiListClipper clipper)
		{
			fixed (ImGuiListClipper* pclipper = &clipper)
			{
				ResetNative(self, (ImGuiListClipper*)pclipper);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Reset(ref ImGuiListClipperData self, ref ImGuiListClipper clipper)
		{
			fixed (ImGuiListClipperData* pself = &self)
			{
				fixed (ImGuiListClipper* pclipper = &clipper)
				{
					ResetNative((ImGuiListClipperData*)pself, (ImGuiListClipper*)pclipper);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImGuiNavItemData* ImGuiNavItemDataNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImGuiNavItemData*>)funcTable[854])();
			#else
			return (ImGuiNavItemData*)((delegate* unmanaged[Cdecl]<nint>)funcTable[854])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImGuiNavItemDataPtr ImGuiNavItemData()
		{
			ImGuiNavItemDataPtr ret = ImGuiNavItemDataNative();
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ClearNative(ImGuiNavItemData* self)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImGuiNavItemData*, void>)funcTable[855])(self);
			#else
			((delegate* unmanaged[Cdecl]<nint, void>)funcTable[855])((nint)self);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Clear(ImGuiNavItemDataPtr self)
		{
			ClearNative(self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Clear(ref ImGuiNavItemData self)
		{
			fixed (ImGuiNavItemData* pself = &self)
			{
				ClearNative((ImGuiNavItemData*)pself);
			}
		}
	}
}