Dalamud/imgui/Dalamud.Bindings.ImPlot/Generated/Functions/Functions.131.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;
using Dalamud.Bindings.ImGui;

namespace Dalamud.Bindings.ImPlot
{
	public unsafe partial class ImPlot
	{

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapSlider(string label, float* t, ref Vector4 output, string format)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (label != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(label);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (Vector4* poutput = &output)
			{
				byte* pStr1 = null;
				int pStrSize1 = 0;
				if (format != null)
				{
					pStrSize1 = Utils.GetByteCountUTF8(format);
					if (pStrSize1 >= Utils.MaxStackallocSize)
					{
						pStr1 = Utils.Alloc<byte>(pStrSize1 + 1);
					}
					else
					{
						byte* pStrStack1 = stackalloc byte[pStrSize1 + 1];
						pStr1 = pStrStack1;
					}
					int pStrOffset1 = Utils.EncodeStringUTF8(format, pStr1, pStrSize1);
					pStr1[pStrOffset1] = 0;
				}
				byte ret = ColormapSliderNative(pStr0, t, (Vector4*)poutput, pStr1, (ImPlotColormap)(-1));
				if (pStrSize1 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr1);
				}
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapSlider(ref byte label, float* t, ref Vector4 output, ReadOnlySpan<byte> format, ImPlotColormap cmap)
		{
			fixed (byte* plabel = &label)
			{
				fixed (Vector4* poutput = &output)
				{
					fixed (byte* pformat = format)
					{
						byte ret = ColormapSliderNative((byte*)plabel, t, (Vector4*)poutput, (byte*)pformat, cmap);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapSlider(ref byte label, float* t, ref Vector4 output, ReadOnlySpan<byte> format)
		{
			fixed (byte* plabel = &label)
			{
				fixed (Vector4* poutput = &output)
				{
					fixed (byte* pformat = format)
					{
						byte ret = ColormapSliderNative((byte*)plabel, t, (Vector4*)poutput, (byte*)pformat, (ImPlotColormap)(-1));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapSlider(ref byte label, float* t, ref Vector4 output, string format, ImPlotColormap cmap)
		{
			fixed (byte* plabel = &label)
			{
				fixed (Vector4* poutput = &output)
				{
					byte* pStr0 = null;
					int pStrSize0 = 0;
					if (format != null)
					{
						pStrSize0 = Utils.GetByteCountUTF8(format);
						if (pStrSize0 >= Utils.MaxStackallocSize)
						{
							pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
						}
						else
						{
							byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
							pStr0 = pStrStack0;
						}
						int pStrOffset0 = Utils.EncodeStringUTF8(format, pStr0, pStrSize0);
						pStr0[pStrOffset0] = 0;
					}
					byte ret = ColormapSliderNative((byte*)plabel, t, (Vector4*)poutput, pStr0, cmap);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						Utils.Free(pStr0);
					}
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapSlider(ref byte label, float* t, ref Vector4 output, string format)
		{
			fixed (byte* plabel = &label)
			{
				fixed (Vector4* poutput = &output)
				{
					byte* pStr0 = null;
					int pStrSize0 = 0;
					if (format != null)
					{
						pStrSize0 = Utils.GetByteCountUTF8(format);
						if (pStrSize0 >= Utils.MaxStackallocSize)
						{
							pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
						}
						else
						{
							byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
							pStr0 = pStrStack0;
						}
						int pStrOffset0 = Utils.EncodeStringUTF8(format, pStr0, pStrSize0);
						pStr0[pStrOffset0] = 0;
					}
					byte ret = ColormapSliderNative((byte*)plabel, t, (Vector4*)poutput, pStr0, (ImPlotColormap)(-1));
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						Utils.Free(pStr0);
					}
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapSlider(ReadOnlySpan<byte> label, float* t, ref Vector4 output, ref byte format, ImPlotColormap cmap)
		{
			fixed (byte* plabel = label)
			{
				fixed (Vector4* poutput = &output)
				{
					fixed (byte* pformat = &format)
					{
						byte ret = ColormapSliderNative((byte*)plabel, t, (Vector4*)poutput, (byte*)pformat, cmap);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapSlider(ReadOnlySpan<byte> label, float* t, ref Vector4 output, ref byte format)
		{
			fixed (byte* plabel = label)
			{
				fixed (Vector4* poutput = &output)
				{
					fixed (byte* pformat = &format)
					{
						byte ret = ColormapSliderNative((byte*)plabel, t, (Vector4*)poutput, (byte*)pformat, (ImPlotColormap)(-1));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapSlider(ReadOnlySpan<byte> label, float* t, ref Vector4 output, string format, ImPlotColormap cmap)
		{
			fixed (byte* plabel = label)
			{
				fixed (Vector4* poutput = &output)
				{
					byte* pStr0 = null;
					int pStrSize0 = 0;
					if (format != null)
					{
						pStrSize0 = Utils.GetByteCountUTF8(format);
						if (pStrSize0 >= Utils.MaxStackallocSize)
						{
							pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
						}
						else
						{
							byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
							pStr0 = pStrStack0;
						}
						int pStrOffset0 = Utils.EncodeStringUTF8(format, pStr0, pStrSize0);
						pStr0[pStrOffset0] = 0;
					}
					byte ret = ColormapSliderNative((byte*)plabel, t, (Vector4*)poutput, pStr0, cmap);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						Utils.Free(pStr0);
					}
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapSlider(ReadOnlySpan<byte> label, float* t, ref Vector4 output, string format)
		{
			fixed (byte* plabel = label)
			{
				fixed (Vector4* poutput = &output)
				{
					byte* pStr0 = null;
					int pStrSize0 = 0;
					if (format != null)
					{
						pStrSize0 = Utils.GetByteCountUTF8(format);
						if (pStrSize0 >= Utils.MaxStackallocSize)
						{
							pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
						}
						else
						{
							byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
							pStr0 = pStrStack0;
						}
						int pStrOffset0 = Utils.EncodeStringUTF8(format, pStr0, pStrSize0);
						pStr0[pStrOffset0] = 0;
					}
					byte ret = ColormapSliderNative((byte*)plabel, t, (Vector4*)poutput, pStr0, (ImPlotColormap)(-1));
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						Utils.Free(pStr0);
					}
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapSlider(string label, float* t, ref Vector4 output, ref byte format, ImPlotColormap cmap)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (label != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(label);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (Vector4* poutput = &output)
			{
				fixed (byte* pformat = &format)
				{
					byte ret = ColormapSliderNative(pStr0, t, (Vector4*)poutput, (byte*)pformat, cmap);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						Utils.Free(pStr0);
					}
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapSlider(string label, float* t, ref Vector4 output, ref byte format)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (label != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(label);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (Vector4* poutput = &output)
			{
				fixed (byte* pformat = &format)
				{
					byte ret = ColormapSliderNative(pStr0, t, (Vector4*)poutput, (byte*)pformat, (ImPlotColormap)(-1));
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						Utils.Free(pStr0);
					}
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapSlider(string label, float* t, ref Vector4 output, ReadOnlySpan<byte> format, ImPlotColormap cmap)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (label != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(label);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (Vector4* poutput = &output)
			{
				fixed (byte* pformat = format)
				{
					byte ret = ColormapSliderNative(pStr0, t, (Vector4*)poutput, (byte*)pformat, cmap);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						Utils.Free(pStr0);
					}
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapSlider(string label, float* t, ref Vector4 output, ReadOnlySpan<byte> format)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (label != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(label);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (Vector4* poutput = &output)
			{
				fixed (byte* pformat = format)
				{
					byte ret = ColormapSliderNative(pStr0, t, (Vector4*)poutput, (byte*)pformat, (ImPlotColormap)(-1));
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						Utils.Free(pStr0);
					}
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapSlider(byte* label, ref float t, ref Vector4 output, ref byte format, ImPlotColormap cmap)
		{
			fixed (float* pt = &t)
			{
				fixed (Vector4* poutput = &output)
				{
					fixed (byte* pformat = &format)
					{
						byte ret = ColormapSliderNative(label, (float*)pt, (Vector4*)poutput, (byte*)pformat, cmap);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapSlider(byte* label, ref float t, ref Vector4 output, ref byte format)
		{
			fixed (float* pt = &t)
			{
				fixed (Vector4* poutput = &output)
				{
					fixed (byte* pformat = &format)
					{
						byte ret = ColormapSliderNative(label, (float*)pt, (Vector4*)poutput, (byte*)pformat, (ImPlotColormap)(-1));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapSlider(byte* label, ref float t, ref Vector4 output, ReadOnlySpan<byte> format, ImPlotColormap cmap)
		{
			fixed (float* pt = &t)
			{
				fixed (Vector4* poutput = &output)
				{
					fixed (byte* pformat = format)
					{
						byte ret = ColormapSliderNative(label, (float*)pt, (Vector4*)poutput, (byte*)pformat, cmap);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapSlider(byte* label, ref float t, ref Vector4 output, ReadOnlySpan<byte> format)
		{
			fixed (float* pt = &t)
			{
				fixed (Vector4* poutput = &output)
				{
					fixed (byte* pformat = format)
					{
						byte ret = ColormapSliderNative(label, (float*)pt, (Vector4*)poutput, (byte*)pformat, (ImPlotColormap)(-1));
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapSlider(byte* label, ref float t, ref Vector4 output, string format, ImPlotColormap cmap)
		{
			fixed (float* pt = &t)
			{
				fixed (Vector4* poutput = &output)
				{
					byte* pStr0 = null;
					int pStrSize0 = 0;
					if (format != null)
					{
						pStrSize0 = Utils.GetByteCountUTF8(format);
						if (pStrSize0 >= Utils.MaxStackallocSize)
						{
							pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
						}
						else
						{
							byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
							pStr0 = pStrStack0;
						}
						int pStrOffset0 = Utils.EncodeStringUTF8(format, pStr0, pStrSize0);
						pStr0[pStrOffset0] = 0;
					}
					byte ret = ColormapSliderNative(label, (float*)pt, (Vector4*)poutput, pStr0, cmap);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						Utils.Free(pStr0);
					}
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapSlider(byte* label, ref float t, ref Vector4 output, string format)
		{
			fixed (float* pt = &t)
			{
				fixed (Vector4* poutput = &output)
				{
					byte* pStr0 = null;
					int pStrSize0 = 0;
					if (format != null)
					{
						pStrSize0 = Utils.GetByteCountUTF8(format);
						if (pStrSize0 >= Utils.MaxStackallocSize)
						{
							pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
						}
						else
						{
							byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
							pStr0 = pStrStack0;
						}
						int pStrOffset0 = Utils.EncodeStringUTF8(format, pStr0, pStrSize0);
						pStr0[pStrOffset0] = 0;
					}
					byte ret = ColormapSliderNative(label, (float*)pt, (Vector4*)poutput, pStr0, (ImPlotColormap)(-1));
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						Utils.Free(pStr0);
					}
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapSlider(ref byte label, ref float t, ref Vector4 output, ref byte format, ImPlotColormap cmap)
		{
			fixed (byte* plabel = &label)
			{
				fixed (float* pt = &t)
				{
					fixed (Vector4* poutput = &output)
					{
						fixed (byte* pformat = &format)
						{
							byte ret = ColormapSliderNative((byte*)plabel, (float*)pt, (Vector4*)poutput, (byte*)pformat, cmap);
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapSlider(ref byte label, ref float t, ref Vector4 output, ref byte format)
		{
			fixed (byte* plabel = &label)
			{
				fixed (float* pt = &t)
				{
					fixed (Vector4* poutput = &output)
					{
						fixed (byte* pformat = &format)
						{
							byte ret = ColormapSliderNative((byte*)plabel, (float*)pt, (Vector4*)poutput, (byte*)pformat, (ImPlotColormap)(-1));
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapSlider(ReadOnlySpan<byte> label, ref float t, ref Vector4 output, ReadOnlySpan<byte> format, ImPlotColormap cmap)
		{
			fixed (byte* plabel = label)
			{
				fixed (float* pt = &t)
				{
					fixed (Vector4* poutput = &output)
					{
						fixed (byte* pformat = format)
						{
							byte ret = ColormapSliderNative((byte*)plabel, (float*)pt, (Vector4*)poutput, (byte*)pformat, cmap);
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapSlider(ReadOnlySpan<byte> label, ref float t, ref Vector4 output, ReadOnlySpan<byte> format)
		{
			fixed (byte* plabel = label)
			{
				fixed (float* pt = &t)
				{
					fixed (Vector4* poutput = &output)
					{
						fixed (byte* pformat = format)
						{
							byte ret = ColormapSliderNative((byte*)plabel, (float*)pt, (Vector4*)poutput, (byte*)pformat, (ImPlotColormap)(-1));
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapSlider(string label, ref float t, ref Vector4 output, string format, ImPlotColormap cmap)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (label != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(label);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (float* pt = &t)
			{
				fixed (Vector4* poutput = &output)
				{
					byte* pStr1 = null;
					int pStrSize1 = 0;
					if (format != null)
					{
						pStrSize1 = Utils.GetByteCountUTF8(format);
						if (pStrSize1 >= Utils.MaxStackallocSize)
						{
							pStr1 = Utils.Alloc<byte>(pStrSize1 + 1);
						}
						else
						{
							byte* pStrStack1 = stackalloc byte[pStrSize1 + 1];
							pStr1 = pStrStack1;
						}
						int pStrOffset1 = Utils.EncodeStringUTF8(format, pStr1, pStrSize1);
						pStr1[pStrOffset1] = 0;
					}
					byte ret = ColormapSliderNative(pStr0, (float*)pt, (Vector4*)poutput, pStr1, cmap);
					if (pStrSize1 >= Utils.MaxStackallocSize)
					{
						Utils.Free(pStr1);
					}
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						Utils.Free(pStr0);
					}
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapSlider(string label, ref float t, ref Vector4 output, string format)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (label != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(label);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (float* pt = &t)
			{
				fixed (Vector4* poutput = &output)
				{
					byte* pStr1 = null;
					int pStrSize1 = 0;
					if (format != null)
					{
						pStrSize1 = Utils.GetByteCountUTF8(format);
						if (pStrSize1 >= Utils.MaxStackallocSize)
						{
							pStr1 = Utils.Alloc<byte>(pStrSize1 + 1);
						}
						else
						{
							byte* pStrStack1 = stackalloc byte[pStrSize1 + 1];
							pStr1 = pStrStack1;
						}
						int pStrOffset1 = Utils.EncodeStringUTF8(format, pStr1, pStrSize1);
						pStr1[pStrOffset1] = 0;
					}
					byte ret = ColormapSliderNative(pStr0, (float*)pt, (Vector4*)poutput, pStr1, (ImPlotColormap)(-1));
					if (pStrSize1 >= Utils.MaxStackallocSize)
					{
						Utils.Free(pStr1);
					}
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						Utils.Free(pStr0);
					}
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapSlider(ref byte label, ref float t, ref Vector4 output, ReadOnlySpan<byte> format, ImPlotColormap cmap)
		{
			fixed (byte* plabel = &label)
			{
				fixed (float* pt = &t)
				{
					fixed (Vector4* poutput = &output)
					{
						fixed (byte* pformat = format)
						{
							byte ret = ColormapSliderNative((byte*)plabel, (float*)pt, (Vector4*)poutput, (byte*)pformat, cmap);
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapSlider(ref byte label, ref float t, ref Vector4 output, ReadOnlySpan<byte> format)
		{
			fixed (byte* plabel = &label)
			{
				fixed (float* pt = &t)
				{
					fixed (Vector4* poutput = &output)
					{
						fixed (byte* pformat = format)
						{
							byte ret = ColormapSliderNative((byte*)plabel, (float*)pt, (Vector4*)poutput, (byte*)pformat, (ImPlotColormap)(-1));
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapSlider(ref byte label, ref float t, ref Vector4 output, string format, ImPlotColormap cmap)
		{
			fixed (byte* plabel = &label)
			{
				fixed (float* pt = &t)
				{
					fixed (Vector4* poutput = &output)
					{
						byte* pStr0 = null;
						int pStrSize0 = 0;
						if (format != null)
						{
							pStrSize0 = Utils.GetByteCountUTF8(format);
							if (pStrSize0 >= Utils.MaxStackallocSize)
							{
								pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
							}
							else
							{
								byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
								pStr0 = pStrStack0;
							}
							int pStrOffset0 = Utils.EncodeStringUTF8(format, pStr0, pStrSize0);
							pStr0[pStrOffset0] = 0;
						}
						byte ret = ColormapSliderNative((byte*)plabel, (float*)pt, (Vector4*)poutput, pStr0, cmap);
						if (pStrSize0 >= Utils.MaxStackallocSize)
						{
							Utils.Free(pStr0);
						}
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapSlider(ref byte label, ref float t, ref Vector4 output, string format)
		{
			fixed (byte* plabel = &label)
			{
				fixed (float* pt = &t)
				{
					fixed (Vector4* poutput = &output)
					{
						byte* pStr0 = null;
						int pStrSize0 = 0;
						if (format != null)
						{
							pStrSize0 = Utils.GetByteCountUTF8(format);
							if (pStrSize0 >= Utils.MaxStackallocSize)
							{
								pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
							}
							else
							{
								byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
								pStr0 = pStrStack0;
							}
							int pStrOffset0 = Utils.EncodeStringUTF8(format, pStr0, pStrSize0);
							pStr0[pStrOffset0] = 0;
						}
						byte ret = ColormapSliderNative((byte*)plabel, (float*)pt, (Vector4*)poutput, pStr0, (ImPlotColormap)(-1));
						if (pStrSize0 >= Utils.MaxStackallocSize)
						{
							Utils.Free(pStr0);
						}
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapSlider(ReadOnlySpan<byte> label, ref float t, ref Vector4 output, ref byte format, ImPlotColormap cmap)
		{
			fixed (byte* plabel = label)
			{
				fixed (float* pt = &t)
				{
					fixed (Vector4* poutput = &output)
					{
						fixed (byte* pformat = &format)
						{
							byte ret = ColormapSliderNative((byte*)plabel, (float*)pt, (Vector4*)poutput, (byte*)pformat, cmap);
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapSlider(ReadOnlySpan<byte> label, ref float t, ref Vector4 output, ref byte format)
		{
			fixed (byte* plabel = label)
			{
				fixed (float* pt = &t)
				{
					fixed (Vector4* poutput = &output)
					{
						fixed (byte* pformat = &format)
						{
							byte ret = ColormapSliderNative((byte*)plabel, (float*)pt, (Vector4*)poutput, (byte*)pformat, (ImPlotColormap)(-1));
							return ret != 0;
						}
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapSlider(ReadOnlySpan<byte> label, ref float t, ref Vector4 output, string format, ImPlotColormap cmap)
		{
			fixed (byte* plabel = label)
			{
				fixed (float* pt = &t)
				{
					fixed (Vector4* poutput = &output)
					{
						byte* pStr0 = null;
						int pStrSize0 = 0;
						if (format != null)
						{
							pStrSize0 = Utils.GetByteCountUTF8(format);
							if (pStrSize0 >= Utils.MaxStackallocSize)
							{
								pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
							}
							else
							{
								byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
								pStr0 = pStrStack0;
							}
							int pStrOffset0 = Utils.EncodeStringUTF8(format, pStr0, pStrSize0);
							pStr0[pStrOffset0] = 0;
						}
						byte ret = ColormapSliderNative((byte*)plabel, (float*)pt, (Vector4*)poutput, pStr0, cmap);
						if (pStrSize0 >= Utils.MaxStackallocSize)
						{
							Utils.Free(pStr0);
						}
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapSlider(ReadOnlySpan<byte> label, ref float t, ref Vector4 output, string format)
		{
			fixed (byte* plabel = label)
			{
				fixed (float* pt = &t)
				{
					fixed (Vector4* poutput = &output)
					{
						byte* pStr0 = null;
						int pStrSize0 = 0;
						if (format != null)
						{
							pStrSize0 = Utils.GetByteCountUTF8(format);
							if (pStrSize0 >= Utils.MaxStackallocSize)
							{
								pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
							}
							else
							{
								byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
								pStr0 = pStrStack0;
							}
							int pStrOffset0 = Utils.EncodeStringUTF8(format, pStr0, pStrSize0);
							pStr0[pStrOffset0] = 0;
						}
						byte ret = ColormapSliderNative((byte*)plabel, (float*)pt, (Vector4*)poutput, pStr0, (ImPlotColormap)(-1));
						if (pStrSize0 >= Utils.MaxStackallocSize)
						{
							Utils.Free(pStr0);
						}
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapSlider(string label, ref float t, ref Vector4 output, ref byte format, ImPlotColormap cmap)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (label != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(label);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (float* pt = &t)
			{
				fixed (Vector4* poutput = &output)
				{
					fixed (byte* pformat = &format)
					{
						byte ret = ColormapSliderNative(pStr0, (float*)pt, (Vector4*)poutput, (byte*)pformat, cmap);
						if (pStrSize0 >= Utils.MaxStackallocSize)
						{
							Utils.Free(pStr0);
						}
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapSlider(string label, ref float t, ref Vector4 output, ref byte format)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (label != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(label);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (float* pt = &t)
			{
				fixed (Vector4* poutput = &output)
				{
					fixed (byte* pformat = &format)
					{
						byte ret = ColormapSliderNative(pStr0, (float*)pt, (Vector4*)poutput, (byte*)pformat, (ImPlotColormap)(-1));
						if (pStrSize0 >= Utils.MaxStackallocSize)
						{
							Utils.Free(pStr0);
						}
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapSlider(string label, ref float t, ref Vector4 output, ReadOnlySpan<byte> format, ImPlotColormap cmap)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (label != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(label);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (float* pt = &t)
			{
				fixed (Vector4* poutput = &output)
				{
					fixed (byte* pformat = format)
					{
						byte ret = ColormapSliderNative(pStr0, (float*)pt, (Vector4*)poutput, (byte*)pformat, cmap);
						if (pStrSize0 >= Utils.MaxStackallocSize)
						{
							Utils.Free(pStr0);
						}
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapSlider(string label, ref float t, ref Vector4 output, ReadOnlySpan<byte> format)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (label != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(label);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (float* pt = &t)
			{
				fixed (Vector4* poutput = &output)
				{
					fixed (byte* pformat = format)
					{
						byte ret = ColormapSliderNative(pStr0, (float*)pt, (Vector4*)poutput, (byte*)pformat, (ImPlotColormap)(-1));
						if (pStrSize0 >= Utils.MaxStackallocSize)
						{
							Utils.Free(pStr0);
						}
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte ColormapButtonNative(byte* label, Vector2 size, ImPlotColormap cmap)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<byte*, Vector2, ImPlotColormap, byte>)funcTable[332])(label, size, cmap);
			#else
			return (byte)((delegate* unmanaged[Cdecl]<nint, Vector2, ImPlotColormap, byte>)funcTable[332])((nint)label, size, cmap);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapButton(byte* label, Vector2 size, ImPlotColormap cmap)
		{
			byte ret = ColormapButtonNative(label, size, cmap);
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapButton(byte* label, Vector2 size)
		{
			byte ret = ColormapButtonNative(label, size, (ImPlotColormap)(-1));
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapButton(byte* label)
		{
			byte ret = ColormapButtonNative(label, (Vector2)(new Vector2(0,0)), (ImPlotColormap)(-1));
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapButton(byte* label, ImPlotColormap cmap)
		{
			byte ret = ColormapButtonNative(label, (Vector2)(new Vector2(0,0)), cmap);
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapButton(ref byte label, Vector2 size, ImPlotColormap cmap)
		{
			fixed (byte* plabel = &label)
			{
				byte ret = ColormapButtonNative((byte*)plabel, size, cmap);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapButton(ref byte label, Vector2 size)
		{
			fixed (byte* plabel = &label)
			{
				byte ret = ColormapButtonNative((byte*)plabel, size, (ImPlotColormap)(-1));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapButton(ref byte label)
		{
			fixed (byte* plabel = &label)
			{
				byte ret = ColormapButtonNative((byte*)plabel, (Vector2)(new Vector2(0,0)), (ImPlotColormap)(-1));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapButton(ref byte label, ImPlotColormap cmap)
		{
			fixed (byte* plabel = &label)
			{
				byte ret = ColormapButtonNative((byte*)plabel, (Vector2)(new Vector2(0,0)), cmap);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapButton(ReadOnlySpan<byte> label, Vector2 size, ImPlotColormap cmap)
		{
			fixed (byte* plabel = label)
			{
				byte ret = ColormapButtonNative((byte*)plabel, size, cmap);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapButton(ReadOnlySpan<byte> label, Vector2 size)
		{
			fixed (byte* plabel = label)
			{
				byte ret = ColormapButtonNative((byte*)plabel, size, (ImPlotColormap)(-1));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapButton(ReadOnlySpan<byte> label)
		{
			fixed (byte* plabel = label)
			{
				byte ret = ColormapButtonNative((byte*)plabel, (Vector2)(new Vector2(0,0)), (ImPlotColormap)(-1));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapButton(ReadOnlySpan<byte> label, ImPlotColormap cmap)
		{
			fixed (byte* plabel = label)
			{
				byte ret = ColormapButtonNative((byte*)plabel, (Vector2)(new Vector2(0,0)), cmap);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapButton(string label, Vector2 size, ImPlotColormap cmap)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (label != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(label);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			byte ret = ColormapButtonNative(pStr0, size, cmap);
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapButton(string label, Vector2 size)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (label != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(label);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			byte ret = ColormapButtonNative(pStr0, size, (ImPlotColormap)(-1));
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapButton(string label)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (label != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(label);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			byte ret = ColormapButtonNative(pStr0, (Vector2)(new Vector2(0,0)), (ImPlotColormap)(-1));
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ColormapButton(string label, ImPlotColormap cmap)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (label != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(label);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			byte ret = ColormapButtonNative(pStr0, (Vector2)(new Vector2(0,0)), cmap);
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
			return ret != 0;
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void BustColorCache(byte* plotTitleId)
		{
			BustColorCacheNative(plotTitleId);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void BustColorCache()
		{
			BustColorCacheNative((byte*)(((void*)0)));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void BustColorCache(ref byte plotTitleId)
		{
			fixed (byte* pplotTitleId = &plotTitleId)
			{
				BustColorCacheNative((byte*)pplotTitleId);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void BustColorCache(ReadOnlySpan<byte> plotTitleId)
		{
			fixed (byte* pplotTitleId = plotTitleId)
			{
				BustColorCacheNative((byte*)pplotTitleId);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void BustColorCache(string plotTitleId)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (plotTitleId != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(plotTitleId);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(plotTitleId, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			BustColorCacheNative(pStr0);
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImPlotInputMapPtr GetInputMap()
		{
			ImPlotInputMapPtr ret = GetInputMapNative();
			return ret;
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void MapInputDefault(ImPlotInputMapPtr dst)
		{
			MapInputDefaultNative(dst);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void MapInputDefault()
		{
			MapInputDefaultNative((ImPlotInputMap*)(((void*)0)));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void MapInputDefault(ref ImPlotInputMap dst)
		{
			fixed (ImPlotInputMap* pdst = &dst)
			{
				MapInputDefaultNative((ImPlotInputMap*)pdst);
			}
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void MapInputReverse(ImPlotInputMapPtr dst)
		{
			MapInputReverseNative(dst);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void MapInputReverse()
		{
			MapInputReverseNative((ImPlotInputMap*)(((void*)0)));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void MapInputReverse(ref ImPlotInputMap dst)
		{
			fixed (ImPlotInputMap* pdst = &dst)
			{
				MapInputReverseNative((ImPlotInputMap*)pdst);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ItemIconNative(Vector4 col)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<Vector4, void>)funcTable[337])(col);
			#else
			((delegate* unmanaged[Cdecl]<Vector4, void>)funcTable[337])(col);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ItemIcon(Vector4 col)
		{
			ItemIconNative(col);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ItemIconNative(uint col)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<uint, void>)funcTable[338])(col);
			#else
			((delegate* unmanaged[Cdecl]<uint, void>)funcTable[338])(col);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ItemIcon(uint col)
		{
			ItemIconNative(col);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ColormapIconNative(ImPlotColormap cmap)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImPlotColormap, void>)funcTable[339])(cmap);
			#else
			((delegate* unmanaged[Cdecl]<ImPlotColormap, void>)funcTable[339])(cmap);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ColormapIcon(ImPlotColormap cmap)
		{
			ColormapIconNative(cmap);
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImDrawListPtr GetPlotDrawList()
		{
			ImDrawListPtr ret = GetPlotDrawListNative();
			return ret;
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PushPlotClipRect(float expand)
		{
			PushPlotClipRectNative(expand);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PushPlotClipRect()
		{
			PushPlotClipRectNative((float)(0));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void PopPlotClipRectNative()
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<void>)funcTable[342])();
			#else
			((delegate* unmanaged[Cdecl]<void>)funcTable[342])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PopPlotClipRect()
		{
			PopPlotClipRectNative();
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ShowStyleSelector(byte* label)
		{
			byte ret = ShowStyleSelectorNative(label);
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ShowStyleSelector(ref byte label)
		{
			fixed (byte* plabel = &label)
			{
				byte ret = ShowStyleSelectorNative((byte*)plabel);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ShowStyleSelector(ReadOnlySpan<byte> label)
		{
			fixed (byte* plabel = label)
			{
				byte ret = ShowStyleSelectorNative((byte*)plabel);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ShowStyleSelector(string label)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (label != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(label);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			byte ret = ShowStyleSelectorNative(pStr0);
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
			return ret != 0;
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ShowColormapSelector(byte* label)
		{
			byte ret = ShowColormapSelectorNative(label);
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ShowColormapSelector(ref byte label)
		{
			fixed (byte* plabel = &label)
			{
				byte ret = ShowColormapSelectorNative((byte*)plabel);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ShowColormapSelector(ReadOnlySpan<byte> label)
		{
			fixed (byte* plabel = label)
			{
				byte ret = ShowColormapSelectorNative((byte*)plabel);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ShowColormapSelector(string label)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (label != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(label);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			byte ret = ShowColormapSelectorNative(pStr0);
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
			return ret != 0;
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ShowInputMapSelector(byte* label)
		{
			byte ret = ShowInputMapSelectorNative(label);
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ShowInputMapSelector(ref byte label)
		{
			fixed (byte* plabel = &label)
			{
				byte ret = ShowInputMapSelectorNative((byte*)plabel);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ShowInputMapSelector(ReadOnlySpan<byte> label)
		{
			fixed (byte* plabel = label)
			{
				byte ret = ShowInputMapSelectorNative((byte*)plabel);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ShowInputMapSelector(string label)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (label != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(label);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(label, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			byte ret = ShowInputMapSelectorNative(pStr0);
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
			return ret != 0;
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ShowStyleEditor(ImPlotStylePtr reference)
		{
			ShowStyleEditorNative(reference);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ShowStyleEditor()
		{
			ShowStyleEditorNative((ImPlotStyle*)(((void*)0)));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ShowStyleEditor(ref ImPlotStyle reference)
		{
			fixed (ImPlotStyle* preference = &reference)
			{
				ShowStyleEditorNative((ImPlotStyle*)preference);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ShowUserGuideNative()
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<void>)funcTable[347])();
			#else
			((delegate* unmanaged[Cdecl]<void>)funcTable[347])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ShowUserGuide()
		{
			ShowUserGuideNative();
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ShowMetricsWindow(bool* pPopen)
		{
			ShowMetricsWindowNative(pPopen);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ShowMetricsWindow()
		{
			ShowMetricsWindowNative((bool*)(((void*)0)));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ShowMetricsWindow(ref bool pPopen)
		{
			fixed (bool* ppPopen = &pPopen)
			{
				ShowMetricsWindowNative((bool*)ppPopen);
			}
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ShowDemoWindow(bool* pOpen)
		{
			ShowDemoWindowNative(pOpen);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ShowDemoWindow()
		{
			ShowDemoWindowNative((bool*)(((void*)0)));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ShowDemoWindow(ref bool pOpen)
		{
			fixed (bool* ppOpen = &pOpen)
			{
				ShowDemoWindowNative((bool*)ppOpen);
			}
		}

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

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

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

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

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

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

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

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

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

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

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

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

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float ImRemap(float x, float x0, float x1, float y0, float y1)
		{
			float ret = ImRemapNative(x, x0, x1, y0, y1);
			return ret;
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static double ImRemap(double x, double x0, double x1, double y0, double y1)
		{
			double ret = ImRemapNative(x, x0, x1, y0, y1);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte ImRemapNative(byte x, byte x0, byte x1, byte y0, byte y1)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<byte, byte, byte, byte, byte, byte>)funcTable[358])(x, x0, x1, y0, y1);
			#else
			return (byte)((delegate* unmanaged[Cdecl]<byte, byte, byte, byte, byte, byte>)funcTable[358])(x, x0, x1, y0, y1);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static byte ImRemap(byte x, byte x0, byte x1, byte y0, byte y1)
		{
			byte ret = ImRemapNative(x, x0, x1, y0, y1);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static short ImRemapNative(short x, short x0, short x1, short y0, short y1)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<short, short, short, short, short, short>)funcTable[359])(x, x0, x1, y0, y1);
			#else
			return (short)((delegate* unmanaged[Cdecl]<short, short, short, short, short, short>)funcTable[359])(x, x0, x1, y0, y1);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static short ImRemap(short x, short x0, short x1, short y0, short y1)
		{
			short ret = ImRemapNative(x, x0, x1, y0, y1);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ushort ImRemapNative(ushort x, ushort x0, ushort x1, ushort y0, ushort y1)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ushort, ushort, ushort, ushort, ushort, ushort>)funcTable[360])(x, x0, x1, y0, y1);
			#else
			return (ushort)((delegate* unmanaged[Cdecl]<ushort, ushort, ushort, ushort, ushort, ushort>)funcTable[360])(x, x0, x1, y0, y1);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ushort ImRemap(ushort x, ushort x0, ushort x1, ushort y0, ushort y1)
		{
			ushort ret = ImRemapNative(x, x0, x1, y0, y1);
			return ret;
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int ImRemap(int x, int x0, int x1, int y0, int y1)
		{
			int ret = ImRemapNative(x, x0, x1, y0, y1);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static uint ImRemapNative(uint x, uint x0, uint x1, uint y0, uint y1)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<uint, uint, uint, uint, uint, uint>)funcTable[362])(x, x0, x1, y0, y1);
			#else
			return (uint)((delegate* unmanaged[Cdecl]<uint, uint, uint, uint, uint, uint>)funcTable[362])(x, x0, x1, y0, y1);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint ImRemap(uint x, uint x0, uint x1, uint y0, uint y1)
		{
			uint ret = ImRemapNative(x, x0, x1, y0, y1);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static long ImRemapNative(long x, long x0, long x1, long y0, long y1)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<long, long, long, long, long, long>)funcTable[363])(x, x0, x1, y0, y1);
			#else
			return (long)((delegate* unmanaged[Cdecl]<long, long, long, long, long, long>)funcTable[363])(x, x0, x1, y0, y1);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static long ImRemap(long x, long x0, long x1, long y0, long y1)
		{
			long ret = ImRemapNative(x, x0, x1, y0, y1);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ulong ImRemapNative(ulong x, ulong x0, ulong x1, ulong y0, ulong y1)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ulong, ulong, ulong, ulong, ulong, ulong>)funcTable[364])(x, x0, x1, y0, y1);
			#else
			return (ulong)((delegate* unmanaged[Cdecl]<ulong, ulong, ulong, ulong, ulong, ulong>)funcTable[364])(x, x0, x1, y0, y1);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ulong ImRemap(ulong x, ulong x0, ulong x1, ulong y0, ulong y1)
		{
			ulong ret = ImRemapNative(x, x0, x1, y0, y1);
			return ret;
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float ImRemap01(float x, float x0, float x1)
		{
			float ret = ImRemap01Native(x, x0, x1);
			return ret;
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static double ImRemap01(double x, double x0, double x1)
		{
			double ret = ImRemap01Native(x, x0, x1);
			return ret;
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static byte ImRemap01(byte x, byte x0, byte x1)
		{
			byte ret = ImRemap01Native(x, x0, x1);
			return ret;
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static short ImRemap01(short x, short x0, short x1)
		{
			short ret = ImRemap01Native(x, x0, x1);
			return ret;
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ushort ImRemap01(ushort x, ushort x0, ushort x1)
		{
			ushort ret = ImRemap01Native(x, x0, x1);
			return ret;
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int ImRemap01(int x, int x0, int x1)
		{
			int ret = ImRemap01Native(x, x0, x1);
			return ret;
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint ImRemap01(uint x, uint x0, uint x1)
		{
			uint ret = ImRemap01Native(x, x0, x1);
			return ret;
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static long ImRemap01(long x, long x0, long x1)
		{
			long ret = ImRemap01Native(x, x0, x1);
			return ret;
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ulong ImRemap01(ulong x, ulong x0, ulong x1)
		{
			ulong ret = ImRemap01Native(x, x0, x1);
			return ret;
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int ImPosMod(int l, int r)
		{
			int ret = ImPosModNative(l, r);
			return ret;
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ImNan(double val)
		{
			byte ret = ImNanNative(val);
			return ret != 0;
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ImNanOrInf(double val)
		{
			byte ret = ImNanOrInfNative(val);
			return ret != 0;
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static double ImConstrainNan(double val)
		{
			double ret = ImConstrainNanNative(val);
			return ret;
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static double ImConstrainInf(double val)
		{
			double ret = ImConstrainInfNative(val);
			return ret;
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static double ImConstrainLog(double val)
		{
			double ret = ImConstrainLogNative(val);
			return ret;
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static double ImConstrainTime(double val)
		{
			double ret = ImConstrainTimeNative(val);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte ImAlmostEqualNative(double v1, double v2, int ulp)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<double, double, int, byte>)funcTable[381])(v1, v2, ulp);
			#else
			return (byte)((delegate* unmanaged[Cdecl]<double, double, int, byte>)funcTable[381])(v1, v2, ulp);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ImAlmostEqual(double v1, double v2, int ulp)
		{
			byte ret = ImAlmostEqualNative(v1, v2, ulp);
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool ImAlmostEqual(double v1, double v2)
		{
			byte ret = ImAlmostEqualNative(v1, v2, (int)(2));
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static float ImMinArrayNative(float* values, int count)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<float*, int, float>)funcTable[382])(values, count);
			#else
			return (float)((delegate* unmanaged[Cdecl]<nint, int, float>)funcTable[382])((nint)values, count);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float ImMinArray(float* values, int count)
		{
			float ret = ImMinArrayNative(values, count);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float ImMinArray(ref float values, int count)
		{
			fixed (float* pvalues = &values)
			{
				float ret = ImMinArrayNative((float*)pvalues, count);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static double ImMinArrayNative(double* values, int count)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<double*, int, double>)funcTable[383])(values, count);
			#else
			return (double)((delegate* unmanaged[Cdecl]<nint, int, double>)funcTable[383])((nint)values, count);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static double ImMinArray(double* values, int count)
		{
			double ret = ImMinArrayNative(values, count);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static double ImMinArray(ref double values, int count)
		{
			fixed (double* pvalues = &values)
			{
				double ret = ImMinArrayNative((double*)pvalues, count);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte ImMinArrayNative(byte* values, int count)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<byte*, int, byte>)funcTable[384])(values, count);
			#else
			return (byte)((delegate* unmanaged[Cdecl]<nint, int, byte>)funcTable[384])((nint)values, count);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static byte ImMinArray(byte* values, int count)
		{
			byte ret = ImMinArrayNative(values, count);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static byte ImMinArray(ref byte values, int count)
		{
			fixed (byte* pvalues = &values)
			{
				byte ret = ImMinArrayNative((byte*)pvalues, count);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static short ImMinArrayNative(short* values, int count)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<short*, int, short>)funcTable[385])(values, count);
			#else
			return (short)((delegate* unmanaged[Cdecl]<nint, int, short>)funcTable[385])((nint)values, count);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static short ImMinArray(short* values, int count)
		{
			short ret = ImMinArrayNative(values, count);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static short ImMinArray(ref short values, int count)
		{
			fixed (short* pvalues = &values)
			{
				short ret = ImMinArrayNative((short*)pvalues, count);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ushort ImMinArrayNative(ushort* values, int count)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ushort*, int, ushort>)funcTable[386])(values, count);
			#else
			return (ushort)((delegate* unmanaged[Cdecl]<nint, int, ushort>)funcTable[386])((nint)values, count);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ushort ImMinArray(ushort* values, int count)
		{
			ushort ret = ImMinArrayNative(values, count);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ushort ImMinArray(ref ushort values, int count)
		{
			fixed (ushort* pvalues = &values)
			{
				ushort ret = ImMinArrayNative((ushort*)pvalues, count);
				return ret;
			}
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int ImMinArray(int* values, int count)
		{
			int ret = ImMinArrayNative(values, count);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int ImMinArray(ref int values, int count)
		{
			fixed (int* pvalues = &values)
			{
				int ret = ImMinArrayNative((int*)pvalues, count);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static uint ImMinArrayNative(uint* values, int count)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<uint*, int, uint>)funcTable[388])(values, count);
			#else
			return (uint)((delegate* unmanaged[Cdecl]<nint, int, uint>)funcTable[388])((nint)values, count);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint ImMinArray(uint* values, int count)
		{
			uint ret = ImMinArrayNative(values, count);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint ImMinArray(ref uint values, int count)
		{
			fixed (uint* pvalues = &values)
			{
				uint ret = ImMinArrayNative((uint*)pvalues, count);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static long ImMinArrayNative(long* values, int count)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<long*, int, long>)funcTable[389])(values, count);
			#else
			return (long)((delegate* unmanaged[Cdecl]<nint, int, long>)funcTable[389])((nint)values, count);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static long ImMinArray(long* values, int count)
		{
			long ret = ImMinArrayNative(values, count);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static long ImMinArray(ref long values, int count)
		{
			fixed (long* pvalues = &values)
			{
				long ret = ImMinArrayNative((long*)pvalues, count);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ulong ImMinArrayNative(ulong* values, int count)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ulong*, int, ulong>)funcTable[390])(values, count);
			#else
			return (ulong)((delegate* unmanaged[Cdecl]<nint, int, ulong>)funcTable[390])((nint)values, count);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ulong ImMinArray(ulong* values, int count)
		{
			ulong ret = ImMinArrayNative(values, count);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ulong ImMinArray(ref ulong values, int count)
		{
			fixed (ulong* pvalues = &values)
			{
				ulong ret = ImMinArrayNative((ulong*)pvalues, count);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static float ImMaxArrayNative(float* values, int count)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<float*, int, float>)funcTable[391])(values, count);
			#else
			return (float)((delegate* unmanaged[Cdecl]<nint, int, float>)funcTable[391])((nint)values, count);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float ImMaxArray(float* values, int count)
		{
			float ret = ImMaxArrayNative(values, count);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float ImMaxArray(ref float values, int count)
		{
			fixed (float* pvalues = &values)
			{
				float ret = ImMaxArrayNative((float*)pvalues, count);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static double ImMaxArrayNative(double* values, int count)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<double*, int, double>)funcTable[392])(values, count);
			#else
			return (double)((delegate* unmanaged[Cdecl]<nint, int, double>)funcTable[392])((nint)values, count);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static double ImMaxArray(double* values, int count)
		{
			double ret = ImMaxArrayNative(values, count);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static double ImMaxArray(ref double values, int count)
		{
			fixed (double* pvalues = &values)
			{
				double ret = ImMaxArrayNative((double*)pvalues, count);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte ImMaxArrayNative(byte* values, int count)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<byte*, int, byte>)funcTable[393])(values, count);
			#else
			return (byte)((delegate* unmanaged[Cdecl]<nint, int, byte>)funcTable[393])((nint)values, count);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static byte ImMaxArray(byte* values, int count)
		{
			byte ret = ImMaxArrayNative(values, count);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static byte ImMaxArray(ref byte values, int count)
		{
			fixed (byte* pvalues = &values)
			{
				byte ret = ImMaxArrayNative((byte*)pvalues, count);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static short ImMaxArrayNative(short* values, int count)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<short*, int, short>)funcTable[394])(values, count);
			#else
			return (short)((delegate* unmanaged[Cdecl]<nint, int, short>)funcTable[394])((nint)values, count);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static short ImMaxArray(short* values, int count)
		{
			short ret = ImMaxArrayNative(values, count);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static short ImMaxArray(ref short values, int count)
		{
			fixed (short* pvalues = &values)
			{
				short ret = ImMaxArrayNative((short*)pvalues, count);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ushort ImMaxArrayNative(ushort* values, int count)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ushort*, int, ushort>)funcTable[395])(values, count);
			#else
			return (ushort)((delegate* unmanaged[Cdecl]<nint, int, ushort>)funcTable[395])((nint)values, count);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ushort ImMaxArray(ushort* values, int count)
		{
			ushort ret = ImMaxArrayNative(values, count);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ushort ImMaxArray(ref ushort values, int count)
		{
			fixed (ushort* pvalues = &values)
			{
				ushort ret = ImMaxArrayNative((ushort*)pvalues, count);
				return ret;
			}
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int ImMaxArray(int* values, int count)
		{
			int ret = ImMaxArrayNative(values, count);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int ImMaxArray(ref int values, int count)
		{
			fixed (int* pvalues = &values)
			{
				int ret = ImMaxArrayNative((int*)pvalues, count);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static uint ImMaxArrayNative(uint* values, int count)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<uint*, int, uint>)funcTable[397])(values, count);
			#else
			return (uint)((delegate* unmanaged[Cdecl]<nint, int, uint>)funcTable[397])((nint)values, count);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint ImMaxArray(uint* values, int count)
		{
			uint ret = ImMaxArrayNative(values, count);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint ImMaxArray(ref uint values, int count)
		{
			fixed (uint* pvalues = &values)
			{
				uint ret = ImMaxArrayNative((uint*)pvalues, count);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static long ImMaxArrayNative(long* values, int count)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<long*, int, long>)funcTable[398])(values, count);
			#else
			return (long)((delegate* unmanaged[Cdecl]<nint, int, long>)funcTable[398])((nint)values, count);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static long ImMaxArray(long* values, int count)
		{
			long ret = ImMaxArrayNative(values, count);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static long ImMaxArray(ref long values, int count)
		{
			fixed (long* pvalues = &values)
			{
				long ret = ImMaxArrayNative((long*)pvalues, count);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ulong ImMaxArrayNative(ulong* values, int count)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ulong*, int, ulong>)funcTable[399])(values, count);
			#else
			return (ulong)((delegate* unmanaged[Cdecl]<nint, int, ulong>)funcTable[399])((nint)values, count);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ulong ImMaxArray(ulong* values, int count)
		{
			ulong ret = ImMaxArrayNative(values, count);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ulong ImMaxArray(ref ulong values, int count)
		{
			fixed (ulong* pvalues = &values)
			{
				ulong ret = ImMaxArrayNative((ulong*)pvalues, count);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ImMinMaxArrayNative(float* values, int count, float* minOut, float* maxOut)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<float*, int, float*, float*, void>)funcTable[400])(values, count, minOut, maxOut);
			#else
			((delegate* unmanaged[Cdecl]<nint, int, nint, nint, void>)funcTable[400])((nint)values, count, (nint)minOut, (nint)maxOut);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(float* values, int count, float* minOut, float* maxOut)
		{
			ImMinMaxArrayNative(values, count, minOut, maxOut);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ref float values, int count, float* minOut, float* maxOut)
		{
			fixed (float* pvalues = &values)
			{
				ImMinMaxArrayNative((float*)pvalues, count, minOut, maxOut);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(float* values, int count, ref float minOut, float* maxOut)
		{
			fixed (float* pminOut = &minOut)
			{
				ImMinMaxArrayNative(values, count, (float*)pminOut, maxOut);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ref float values, int count, ref float minOut, float* maxOut)
		{
			fixed (float* pvalues = &values)
			{
				fixed (float* pminOut = &minOut)
				{
					ImMinMaxArrayNative((float*)pvalues, count, (float*)pminOut, maxOut);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(float* values, int count, float* minOut, ref float maxOut)
		{
			fixed (float* pmaxOut = &maxOut)
			{
				ImMinMaxArrayNative(values, count, minOut, (float*)pmaxOut);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ref float values, int count, float* minOut, ref float maxOut)
		{
			fixed (float* pvalues = &values)
			{
				fixed (float* pmaxOut = &maxOut)
				{
					ImMinMaxArrayNative((float*)pvalues, count, minOut, (float*)pmaxOut);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(float* values, int count, ref float minOut, ref float maxOut)
		{
			fixed (float* pminOut = &minOut)
			{
				fixed (float* pmaxOut = &maxOut)
				{
					ImMinMaxArrayNative(values, count, (float*)pminOut, (float*)pmaxOut);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ref float values, int count, ref float minOut, ref float maxOut)
		{
			fixed (float* pvalues = &values)
			{
				fixed (float* pminOut = &minOut)
				{
					fixed (float* pmaxOut = &maxOut)
					{
						ImMinMaxArrayNative((float*)pvalues, count, (float*)pminOut, (float*)pmaxOut);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ImMinMaxArrayNative(double* values, int count, double* minOut, double* maxOut)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<double*, int, double*, double*, void>)funcTable[401])(values, count, minOut, maxOut);
			#else
			((delegate* unmanaged[Cdecl]<nint, int, nint, nint, void>)funcTable[401])((nint)values, count, (nint)minOut, (nint)maxOut);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(double* values, int count, double* minOut, double* maxOut)
		{
			ImMinMaxArrayNative(values, count, minOut, maxOut);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ref double values, int count, double* minOut, double* maxOut)
		{
			fixed (double* pvalues = &values)
			{
				ImMinMaxArrayNative((double*)pvalues, count, minOut, maxOut);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(double* values, int count, ref double minOut, double* maxOut)
		{
			fixed (double* pminOut = &minOut)
			{
				ImMinMaxArrayNative(values, count, (double*)pminOut, maxOut);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ref double values, int count, ref double minOut, double* maxOut)
		{
			fixed (double* pvalues = &values)
			{
				fixed (double* pminOut = &minOut)
				{
					ImMinMaxArrayNative((double*)pvalues, count, (double*)pminOut, maxOut);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(double* values, int count, double* minOut, ref double maxOut)
		{
			fixed (double* pmaxOut = &maxOut)
			{
				ImMinMaxArrayNative(values, count, minOut, (double*)pmaxOut);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ref double values, int count, double* minOut, ref double maxOut)
		{
			fixed (double* pvalues = &values)
			{
				fixed (double* pmaxOut = &maxOut)
				{
					ImMinMaxArrayNative((double*)pvalues, count, minOut, (double*)pmaxOut);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(double* values, int count, ref double minOut, ref double maxOut)
		{
			fixed (double* pminOut = &minOut)
			{
				fixed (double* pmaxOut = &maxOut)
				{
					ImMinMaxArrayNative(values, count, (double*)pminOut, (double*)pmaxOut);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ref double values, int count, ref double minOut, ref double maxOut)
		{
			fixed (double* pvalues = &values)
			{
				fixed (double* pminOut = &minOut)
				{
					fixed (double* pmaxOut = &maxOut)
					{
						ImMinMaxArrayNative((double*)pvalues, count, (double*)pminOut, (double*)pmaxOut);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ImMinMaxArrayNative(byte* values, int count, byte* minOut, byte* maxOut)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<byte*, int, byte*, byte*, void>)funcTable[402])(values, count, minOut, maxOut);
			#else
			((delegate* unmanaged[Cdecl]<nint, int, nint, nint, void>)funcTable[402])((nint)values, count, (nint)minOut, (nint)maxOut);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(byte* values, int count, byte* minOut, byte* maxOut)
		{
			ImMinMaxArrayNative(values, count, minOut, maxOut);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ref byte values, int count, byte* minOut, byte* maxOut)
		{
			fixed (byte* pvalues = &values)
			{
				ImMinMaxArrayNative((byte*)pvalues, count, minOut, maxOut);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(byte* values, int count, ref byte minOut, byte* maxOut)
		{
			fixed (byte* pminOut = &minOut)
			{
				ImMinMaxArrayNative(values, count, (byte*)pminOut, maxOut);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ref byte values, int count, ref byte minOut, byte* maxOut)
		{
			fixed (byte* pvalues = &values)
			{
				fixed (byte* pminOut = &minOut)
				{
					ImMinMaxArrayNative((byte*)pvalues, count, (byte*)pminOut, maxOut);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(byte* values, int count, byte* minOut, ref byte maxOut)
		{
			fixed (byte* pmaxOut = &maxOut)
			{
				ImMinMaxArrayNative(values, count, minOut, (byte*)pmaxOut);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ref byte values, int count, byte* minOut, ref byte maxOut)
		{
			fixed (byte* pvalues = &values)
			{
				fixed (byte* pmaxOut = &maxOut)
				{
					ImMinMaxArrayNative((byte*)pvalues, count, minOut, (byte*)pmaxOut);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(byte* values, int count, ref byte minOut, ref byte maxOut)
		{
			fixed (byte* pminOut = &minOut)
			{
				fixed (byte* pmaxOut = &maxOut)
				{
					ImMinMaxArrayNative(values, count, (byte*)pminOut, (byte*)pmaxOut);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ref byte values, int count, ref byte minOut, ref byte maxOut)
		{
			fixed (byte* pvalues = &values)
			{
				fixed (byte* pminOut = &minOut)
				{
					fixed (byte* pmaxOut = &maxOut)
					{
						ImMinMaxArrayNative((byte*)pvalues, count, (byte*)pminOut, (byte*)pmaxOut);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ImMinMaxArrayNative(short* values, int count, short* minOut, short* maxOut)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<short*, int, short*, short*, void>)funcTable[403])(values, count, minOut, maxOut);
			#else
			((delegate* unmanaged[Cdecl]<nint, int, nint, nint, void>)funcTable[403])((nint)values, count, (nint)minOut, (nint)maxOut);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(short* values, int count, short* minOut, short* maxOut)
		{
			ImMinMaxArrayNative(values, count, minOut, maxOut);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ref short values, int count, short* minOut, short* maxOut)
		{
			fixed (short* pvalues = &values)
			{
				ImMinMaxArrayNative((short*)pvalues, count, minOut, maxOut);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(short* values, int count, ref short minOut, short* maxOut)
		{
			fixed (short* pminOut = &minOut)
			{
				ImMinMaxArrayNative(values, count, (short*)pminOut, maxOut);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ref short values, int count, ref short minOut, short* maxOut)
		{
			fixed (short* pvalues = &values)
			{
				fixed (short* pminOut = &minOut)
				{
					ImMinMaxArrayNative((short*)pvalues, count, (short*)pminOut, maxOut);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(short* values, int count, short* minOut, ref short maxOut)
		{
			fixed (short* pmaxOut = &maxOut)
			{
				ImMinMaxArrayNative(values, count, minOut, (short*)pmaxOut);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ref short values, int count, short* minOut, ref short maxOut)
		{
			fixed (short* pvalues = &values)
			{
				fixed (short* pmaxOut = &maxOut)
				{
					ImMinMaxArrayNative((short*)pvalues, count, minOut, (short*)pmaxOut);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(short* values, int count, ref short minOut, ref short maxOut)
		{
			fixed (short* pminOut = &minOut)
			{
				fixed (short* pmaxOut = &maxOut)
				{
					ImMinMaxArrayNative(values, count, (short*)pminOut, (short*)pmaxOut);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ref short values, int count, ref short minOut, ref short maxOut)
		{
			fixed (short* pvalues = &values)
			{
				fixed (short* pminOut = &minOut)
				{
					fixed (short* pmaxOut = &maxOut)
					{
						ImMinMaxArrayNative((short*)pvalues, count, (short*)pminOut, (short*)pmaxOut);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ImMinMaxArrayNative(ushort* values, int count, ushort* minOut, ushort* maxOut)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ushort*, int, ushort*, ushort*, void>)funcTable[404])(values, count, minOut, maxOut);
			#else
			((delegate* unmanaged[Cdecl]<nint, int, nint, nint, void>)funcTable[404])((nint)values, count, (nint)minOut, (nint)maxOut);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ushort* values, int count, ushort* minOut, ushort* maxOut)
		{
			ImMinMaxArrayNative(values, count, minOut, maxOut);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ref ushort values, int count, ushort* minOut, ushort* maxOut)
		{
			fixed (ushort* pvalues = &values)
			{
				ImMinMaxArrayNative((ushort*)pvalues, count, minOut, maxOut);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ushort* values, int count, ref ushort minOut, ushort* maxOut)
		{
			fixed (ushort* pminOut = &minOut)
			{
				ImMinMaxArrayNative(values, count, (ushort*)pminOut, maxOut);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ref ushort values, int count, ref ushort minOut, ushort* maxOut)
		{
			fixed (ushort* pvalues = &values)
			{
				fixed (ushort* pminOut = &minOut)
				{
					ImMinMaxArrayNative((ushort*)pvalues, count, (ushort*)pminOut, maxOut);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ushort* values, int count, ushort* minOut, ref ushort maxOut)
		{
			fixed (ushort* pmaxOut = &maxOut)
			{
				ImMinMaxArrayNative(values, count, minOut, (ushort*)pmaxOut);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ref ushort values, int count, ushort* minOut, ref ushort maxOut)
		{
			fixed (ushort* pvalues = &values)
			{
				fixed (ushort* pmaxOut = &maxOut)
				{
					ImMinMaxArrayNative((ushort*)pvalues, count, minOut, (ushort*)pmaxOut);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ushort* values, int count, ref ushort minOut, ref ushort maxOut)
		{
			fixed (ushort* pminOut = &minOut)
			{
				fixed (ushort* pmaxOut = &maxOut)
				{
					ImMinMaxArrayNative(values, count, (ushort*)pminOut, (ushort*)pmaxOut);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ref ushort values, int count, ref ushort minOut, ref ushort maxOut)
		{
			fixed (ushort* pvalues = &values)
			{
				fixed (ushort* pminOut = &minOut)
				{
					fixed (ushort* pmaxOut = &maxOut)
					{
						ImMinMaxArrayNative((ushort*)pvalues, count, (ushort*)pminOut, (ushort*)pmaxOut);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ImMinMaxArrayNative(int* values, int count, int* minOut, int* maxOut)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<int*, int, int*, int*, void>)funcTable[405])(values, count, minOut, maxOut);
			#else
			((delegate* unmanaged[Cdecl]<nint, int, nint, nint, void>)funcTable[405])((nint)values, count, (nint)minOut, (nint)maxOut);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(int* values, int count, int* minOut, int* maxOut)
		{
			ImMinMaxArrayNative(values, count, minOut, maxOut);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ref int values, int count, int* minOut, int* maxOut)
		{
			fixed (int* pvalues = &values)
			{
				ImMinMaxArrayNative((int*)pvalues, count, minOut, maxOut);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(int* values, int count, ref int minOut, int* maxOut)
		{
			fixed (int* pminOut = &minOut)
			{
				ImMinMaxArrayNative(values, count, (int*)pminOut, maxOut);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ref int values, int count, ref int minOut, int* maxOut)
		{
			fixed (int* pvalues = &values)
			{
				fixed (int* pminOut = &minOut)
				{
					ImMinMaxArrayNative((int*)pvalues, count, (int*)pminOut, maxOut);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(int* values, int count, int* minOut, ref int maxOut)
		{
			fixed (int* pmaxOut = &maxOut)
			{
				ImMinMaxArrayNative(values, count, minOut, (int*)pmaxOut);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ref int values, int count, int* minOut, ref int maxOut)
		{
			fixed (int* pvalues = &values)
			{
				fixed (int* pmaxOut = &maxOut)
				{
					ImMinMaxArrayNative((int*)pvalues, count, minOut, (int*)pmaxOut);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(int* values, int count, ref int minOut, ref int maxOut)
		{
			fixed (int* pminOut = &minOut)
			{
				fixed (int* pmaxOut = &maxOut)
				{
					ImMinMaxArrayNative(values, count, (int*)pminOut, (int*)pmaxOut);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ref int values, int count, ref int minOut, ref int maxOut)
		{
			fixed (int* pvalues = &values)
			{
				fixed (int* pminOut = &minOut)
				{
					fixed (int* pmaxOut = &maxOut)
					{
						ImMinMaxArrayNative((int*)pvalues, count, (int*)pminOut, (int*)pmaxOut);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ImMinMaxArrayNative(uint* values, int count, uint* minOut, uint* maxOut)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<uint*, int, uint*, uint*, void>)funcTable[406])(values, count, minOut, maxOut);
			#else
			((delegate* unmanaged[Cdecl]<nint, int, nint, nint, void>)funcTable[406])((nint)values, count, (nint)minOut, (nint)maxOut);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(uint* values, int count, uint* minOut, uint* maxOut)
		{
			ImMinMaxArrayNative(values, count, minOut, maxOut);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ref uint values, int count, uint* minOut, uint* maxOut)
		{
			fixed (uint* pvalues = &values)
			{
				ImMinMaxArrayNative((uint*)pvalues, count, minOut, maxOut);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(uint* values, int count, ref uint minOut, uint* maxOut)
		{
			fixed (uint* pminOut = &minOut)
			{
				ImMinMaxArrayNative(values, count, (uint*)pminOut, maxOut);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ref uint values, int count, ref uint minOut, uint* maxOut)
		{
			fixed (uint* pvalues = &values)
			{
				fixed (uint* pminOut = &minOut)
				{
					ImMinMaxArrayNative((uint*)pvalues, count, (uint*)pminOut, maxOut);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(uint* values, int count, uint* minOut, ref uint maxOut)
		{
			fixed (uint* pmaxOut = &maxOut)
			{
				ImMinMaxArrayNative(values, count, minOut, (uint*)pmaxOut);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ref uint values, int count, uint* minOut, ref uint maxOut)
		{
			fixed (uint* pvalues = &values)
			{
				fixed (uint* pmaxOut = &maxOut)
				{
					ImMinMaxArrayNative((uint*)pvalues, count, minOut, (uint*)pmaxOut);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(uint* values, int count, ref uint minOut, ref uint maxOut)
		{
			fixed (uint* pminOut = &minOut)
			{
				fixed (uint* pmaxOut = &maxOut)
				{
					ImMinMaxArrayNative(values, count, (uint*)pminOut, (uint*)pmaxOut);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ref uint values, int count, ref uint minOut, ref uint maxOut)
		{
			fixed (uint* pvalues = &values)
			{
				fixed (uint* pminOut = &minOut)
				{
					fixed (uint* pmaxOut = &maxOut)
					{
						ImMinMaxArrayNative((uint*)pvalues, count, (uint*)pminOut, (uint*)pmaxOut);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ImMinMaxArrayNative(long* values, int count, long* minOut, long* maxOut)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<long*, int, long*, long*, void>)funcTable[407])(values, count, minOut, maxOut);
			#else
			((delegate* unmanaged[Cdecl]<nint, int, nint, nint, void>)funcTable[407])((nint)values, count, (nint)minOut, (nint)maxOut);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(long* values, int count, long* minOut, long* maxOut)
		{
			ImMinMaxArrayNative(values, count, minOut, maxOut);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ref long values, int count, long* minOut, long* maxOut)
		{
			fixed (long* pvalues = &values)
			{
				ImMinMaxArrayNative((long*)pvalues, count, minOut, maxOut);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(long* values, int count, ref long minOut, long* maxOut)
		{
			fixed (long* pminOut = &minOut)
			{
				ImMinMaxArrayNative(values, count, (long*)pminOut, maxOut);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ref long values, int count, ref long minOut, long* maxOut)
		{
			fixed (long* pvalues = &values)
			{
				fixed (long* pminOut = &minOut)
				{
					ImMinMaxArrayNative((long*)pvalues, count, (long*)pminOut, maxOut);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(long* values, int count, long* minOut, ref long maxOut)
		{
			fixed (long* pmaxOut = &maxOut)
			{
				ImMinMaxArrayNative(values, count, minOut, (long*)pmaxOut);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ref long values, int count, long* minOut, ref long maxOut)
		{
			fixed (long* pvalues = &values)
			{
				fixed (long* pmaxOut = &maxOut)
				{
					ImMinMaxArrayNative((long*)pvalues, count, minOut, (long*)pmaxOut);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(long* values, int count, ref long minOut, ref long maxOut)
		{
			fixed (long* pminOut = &minOut)
			{
				fixed (long* pmaxOut = &maxOut)
				{
					ImMinMaxArrayNative(values, count, (long*)pminOut, (long*)pmaxOut);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ref long values, int count, ref long minOut, ref long maxOut)
		{
			fixed (long* pvalues = &values)
			{
				fixed (long* pminOut = &minOut)
				{
					fixed (long* pmaxOut = &maxOut)
					{
						ImMinMaxArrayNative((long*)pvalues, count, (long*)pminOut, (long*)pmaxOut);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ImMinMaxArrayNative(ulong* values, int count, ulong* minOut, ulong* maxOut)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ulong*, int, ulong*, ulong*, void>)funcTable[408])(values, count, minOut, maxOut);
			#else
			((delegate* unmanaged[Cdecl]<nint, int, nint, nint, void>)funcTable[408])((nint)values, count, (nint)minOut, (nint)maxOut);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ulong* values, int count, ulong* minOut, ulong* maxOut)
		{
			ImMinMaxArrayNative(values, count, minOut, maxOut);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ref ulong values, int count, ulong* minOut, ulong* maxOut)
		{
			fixed (ulong* pvalues = &values)
			{
				ImMinMaxArrayNative((ulong*)pvalues, count, minOut, maxOut);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ulong* values, int count, ref ulong minOut, ulong* maxOut)
		{
			fixed (ulong* pminOut = &minOut)
			{
				ImMinMaxArrayNative(values, count, (ulong*)pminOut, maxOut);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ref ulong values, int count, ref ulong minOut, ulong* maxOut)
		{
			fixed (ulong* pvalues = &values)
			{
				fixed (ulong* pminOut = &minOut)
				{
					ImMinMaxArrayNative((ulong*)pvalues, count, (ulong*)pminOut, maxOut);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ulong* values, int count, ulong* minOut, ref ulong maxOut)
		{
			fixed (ulong* pmaxOut = &maxOut)
			{
				ImMinMaxArrayNative(values, count, minOut, (ulong*)pmaxOut);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ref ulong values, int count, ulong* minOut, ref ulong maxOut)
		{
			fixed (ulong* pvalues = &values)
			{
				fixed (ulong* pmaxOut = &maxOut)
				{
					ImMinMaxArrayNative((ulong*)pvalues, count, minOut, (ulong*)pmaxOut);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ulong* values, int count, ref ulong minOut, ref ulong maxOut)
		{
			fixed (ulong* pminOut = &minOut)
			{
				fixed (ulong* pmaxOut = &maxOut)
				{
					ImMinMaxArrayNative(values, count, (ulong*)pminOut, (ulong*)pmaxOut);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void ImMinMaxArray(ref ulong values, int count, ref ulong minOut, ref ulong maxOut)
		{
			fixed (ulong* pvalues = &values)
			{
				fixed (ulong* pminOut = &minOut)
				{
					fixed (ulong* pmaxOut = &maxOut)
					{
						ImMinMaxArrayNative((ulong*)pvalues, count, (ulong*)pminOut, (ulong*)pmaxOut);
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static float ImSumNative(float* values, int count)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<float*, int, float>)funcTable[409])(values, count);
			#else
			return (float)((delegate* unmanaged[Cdecl]<nint, int, float>)funcTable[409])((nint)values, count);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float ImSum(float* values, int count)
		{
			float ret = ImSumNative(values, count);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static float ImSum(ref float values, int count)
		{
			fixed (float* pvalues = &values)
			{
				float ret = ImSumNative((float*)pvalues, count);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static double ImSumNative(double* values, int count)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<double*, int, double>)funcTable[410])(values, count);
			#else
			return (double)((delegate* unmanaged[Cdecl]<nint, int, double>)funcTable[410])((nint)values, count);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static double ImSum(double* values, int count)
		{
			double ret = ImSumNative(values, count);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static double ImSum(ref double values, int count)
		{
			fixed (double* pvalues = &values)
			{
				double ret = ImSumNative((double*)pvalues, count);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte ImSumNative(byte* values, int count)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<byte*, int, byte>)funcTable[411])(values, count);
			#else
			return (byte)((delegate* unmanaged[Cdecl]<nint, int, byte>)funcTable[411])((nint)values, count);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static byte ImSum(byte* values, int count)
		{
			byte ret = ImSumNative(values, count);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static byte ImSum(ref byte values, int count)
		{
			fixed (byte* pvalues = &values)
			{
				byte ret = ImSumNative((byte*)pvalues, count);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static short ImSumNative(short* values, int count)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<short*, int, short>)funcTable[412])(values, count);
			#else
			return (short)((delegate* unmanaged[Cdecl]<nint, int, short>)funcTable[412])((nint)values, count);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static short ImSum(short* values, int count)
		{
			short ret = ImSumNative(values, count);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static short ImSum(ref short values, int count)
		{
			fixed (short* pvalues = &values)
			{
				short ret = ImSumNative((short*)pvalues, count);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ushort ImSumNative(ushort* values, int count)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ushort*, int, ushort>)funcTable[413])(values, count);
			#else
			return (ushort)((delegate* unmanaged[Cdecl]<nint, int, ushort>)funcTable[413])((nint)values, count);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ushort ImSum(ushort* values, int count)
		{
			ushort ret = ImSumNative(values, count);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ushort ImSum(ref ushort values, int count)
		{
			fixed (ushort* pvalues = &values)
			{
				ushort ret = ImSumNative((ushort*)pvalues, count);
				return ret;
			}
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int ImSum(int* values, int count)
		{
			int ret = ImSumNative(values, count);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static int ImSum(ref int values, int count)
		{
			fixed (int* pvalues = &values)
			{
				int ret = ImSumNative((int*)pvalues, count);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static uint ImSumNative(uint* values, int count)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<uint*, int, uint>)funcTable[415])(values, count);
			#else
			return (uint)((delegate* unmanaged[Cdecl]<nint, int, uint>)funcTable[415])((nint)values, count);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint ImSum(uint* values, int count)
		{
			uint ret = ImSumNative(values, count);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static uint ImSum(ref uint values, int count)
		{
			fixed (uint* pvalues = &values)
			{
				uint ret = ImSumNative((uint*)pvalues, count);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static long ImSumNative(long* values, int count)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<long*, int, long>)funcTable[416])(values, count);
			#else
			return (long)((delegate* unmanaged[Cdecl]<nint, int, long>)funcTable[416])((nint)values, count);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static long ImSum(long* values, int count)
		{
			long ret = ImSumNative(values, count);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static long ImSum(ref long values, int count)
		{
			fixed (long* pvalues = &values)
			{
				long ret = ImSumNative((long*)pvalues, count);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ulong ImSumNative(ulong* values, int count)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ulong*, int, ulong>)funcTable[417])(values, count);
			#else
			return (ulong)((delegate* unmanaged[Cdecl]<nint, int, ulong>)funcTable[417])((nint)values, count);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ulong ImSum(ulong* values, int count)
		{
			ulong ret = ImSumNative(values, count);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ulong ImSum(ref ulong values, int count)
		{
			fixed (ulong* pvalues = &values)
			{
				ulong ret = ImSumNative((ulong*)pvalues, count);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static double ImMeanNative(float* values, int count)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<float*, int, double>)funcTable[418])(values, count);
			#else
			return (double)((delegate* unmanaged[Cdecl]<nint, int, double>)funcTable[418])((nint)values, count);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static double ImMean(float* values, int count)
		{
			double ret = ImMeanNative(values, count);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static double ImMean(ref float values, int count)
		{
			fixed (float* pvalues = &values)
			{
				double ret = ImMeanNative((float*)pvalues, count);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static double ImMeanNative(double* values, int count)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<double*, int, double>)funcTable[419])(values, count);
			#else
			return (double)((delegate* unmanaged[Cdecl]<nint, int, double>)funcTable[419])((nint)values, count);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static double ImMean(double* values, int count)
		{
			double ret = ImMeanNative(values, count);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static double ImMean(ref double values, int count)
		{
			fixed (double* pvalues = &values)
			{
				double ret = ImMeanNative((double*)pvalues, count);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static double ImMeanNative(byte* values, int count)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<byte*, int, double>)funcTable[420])(values, count);
			#else
			return (double)((delegate* unmanaged[Cdecl]<nint, int, double>)funcTable[420])((nint)values, count);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static double ImMean(byte* values, int count)
		{
			double ret = ImMeanNative(values, count);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static double ImMean(ref byte values, int count)
		{
			fixed (byte* pvalues = &values)
			{
				double ret = ImMeanNative((byte*)pvalues, count);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static double ImMeanNative(short* values, int count)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<short*, int, double>)funcTable[421])(values, count);
			#else
			return (double)((delegate* unmanaged[Cdecl]<nint, int, double>)funcTable[421])((nint)values, count);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static double ImMean(short* values, int count)
		{
			double ret = ImMeanNative(values, count);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static double ImMean(ref short values, int count)
		{
			fixed (short* pvalues = &values)
			{
				double ret = ImMeanNative((short*)pvalues, count);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static double ImMeanNative(ushort* values, int count)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ushort*, int, double>)funcTable[422])(values, count);
			#else
			return (double)((delegate* unmanaged[Cdecl]<nint, int, double>)funcTable[422])((nint)values, count);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static double ImMean(ushort* values, int count)
		{
			double ret = ImMeanNative(values, count);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static double ImMean(ref ushort values, int count)
		{
			fixed (ushort* pvalues = &values)
			{
				double ret = ImMeanNative((ushort*)pvalues, count);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static double ImMeanNative(int* values, int count)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<int*, int, double>)funcTable[423])(values, count);
			#else
			return (double)((delegate* unmanaged[Cdecl]<nint, int, double>)funcTable[423])((nint)values, count);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static double ImMean(int* values, int count)
		{
			double ret = ImMeanNative(values, count);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static double ImMean(ref int values, int count)
		{
			fixed (int* pvalues = &values)
			{
				double ret = ImMeanNative((int*)pvalues, count);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static double ImMeanNative(uint* values, int count)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<uint*, int, double>)funcTable[424])(values, count);
			#else
			return (double)((delegate* unmanaged[Cdecl]<nint, int, double>)funcTable[424])((nint)values, count);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static double ImMean(uint* values, int count)
		{
			double ret = ImMeanNative(values, count);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static double ImMean(ref uint values, int count)
		{
			fixed (uint* pvalues = &values)
			{
				double ret = ImMeanNative((uint*)pvalues, count);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static double ImMeanNative(long* values, int count)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<long*, int, double>)funcTable[425])(values, count);
			#else
			return (double)((delegate* unmanaged[Cdecl]<nint, int, double>)funcTable[425])((nint)values, count);
			#endif
		}
	}
}