Dalamud/imgui/Dalamud.Bindings.ImPlot/Generated/Functions/Functions.000.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>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImPlotPoint* ImPlotPointNative()
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImPlotPoint*>)funcTable[0])();
			#else
			return (ImPlotPoint*)((delegate* unmanaged[Cdecl]<nint>)funcTable[0])();
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImPlotPointPtr ImPlotPoint()
		{
			ImPlotPointPtr ret = ImPlotPointNative();
			return ret;
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Destroy(ImPlotPointPtr self)
		{
			DestroyNative(self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Destroy(ref ImPlotPoint self)
		{
			fixed (ImPlotPoint* pself = &self)
			{
				DestroyNative((ImPlotPoint*)pself);
			}
		}

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

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

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImPlotPointPtr ImPlotPoint(Vector2 p)
		{
			ImPlotPointPtr ret = ImPlotPointNative(p);
			return ret;
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImPlotRangePtr ImPlotRange()
		{
			ImPlotRangePtr ret = ImPlotRangeNative();
			return ret;
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Destroy(ImPlotRangePtr self)
		{
			DestroyNative(self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Destroy(ref ImPlotRange self)
		{
			fixed (ImPlotRange* pself = &self)
			{
				DestroyNative((ImPlotRange*)pself);
			}
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImPlotRangePtr ImPlotRange(double min, double max)
		{
			ImPlotRangePtr ret = ImPlotRangeNative(min, max);
			return ret;
		}

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

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

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

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static double Size(ImPlotRangePtr self)
		{
			double ret = SizeNative(self);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static double Size(ref ImPlotRange self)
		{
			fixed (ImPlotRange* pself = &self)
			{
				double ret = SizeNative((ImPlotRange*)pself);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static double ClampNative(ImPlotRange* self, double value)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<ImPlotRange*, double, double>)funcTable[9])(self, value);
			#else
			return (double)((delegate* unmanaged[Cdecl]<nint, double, double>)funcTable[9])((nint)self, value);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static double Clamp(ImPlotRangePtr self, double value)
		{
			double ret = ClampNative(self, value);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static double Clamp(ref ImPlotRange self, double value)
		{
			fixed (ImPlotRange* pself = &self)
			{
				double ret = ClampNative((ImPlotRange*)pself, value);
				return ret;
			}
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImPlotRectPtr ImPlotRect()
		{
			ImPlotRectPtr ret = ImPlotRectNative();
			return ret;
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Destroy(ImPlotRectPtr self)
		{
			DestroyNative(self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Destroy(ref ImPlotRect self)
		{
			fixed (ImPlotRect* pself = &self)
			{
				DestroyNative((ImPlotRect*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ImPlotRect* ImPlotRectNative(double xMin, double xMax, double yMin, double yMax)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<double, double, double, double, ImPlotRect*>)funcTable[12])(xMin, xMax, yMin, yMax);
			#else
			return (ImPlotRect*)((delegate* unmanaged[Cdecl]<double, double, double, double, nint>)funcTable[12])(xMin, xMax, yMin, yMax);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImPlotRectPtr ImPlotRect(double xMin, double xMax, double yMin, double yMax)
		{
			ImPlotRectPtr ret = ImPlotRectNative(xMin, xMax, yMin, yMax);
			return ret;
		}

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

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

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

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool Contains(ImPlotRectPtr self, double x, double y)
		{
			byte ret = ContainsNative(self, x, y);
			return ret != 0;
		}

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

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImPlotPoint Size(ImPlotRectPtr self)
		{
			ImPlotPoint ret;
			SizeNative(&ret, self);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Size(ImPlotPointPtr pOut, ImPlotRectPtr self)
		{
			SizeNative(pOut, self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Size(ref ImPlotPoint pOut, ImPlotRectPtr self)
		{
			fixed (ImPlotPoint* ppOut = &pOut)
			{
				SizeNative((ImPlotPoint*)ppOut, self);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImPlotPoint Size(ref ImPlotRect self)
		{
			fixed (ImPlotRect* pself = &self)
			{
				ImPlotPoint ret;
				SizeNative(&ret, (ImPlotRect*)pself);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Size(ImPlotPointPtr pOut, ref ImPlotRect self)
		{
			fixed (ImPlotRect* pself = &self)
			{
				SizeNative(pOut, (ImPlotRect*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Size(ref ImPlotPoint pOut, ref ImPlotRect self)
		{
			fixed (ImPlotPoint* ppOut = &pOut)
			{
				fixed (ImPlotRect* pself = &self)
				{
					SizeNative((ImPlotPoint*)ppOut, (ImPlotRect*)pself);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ClampNative(ImPlotPoint* pOut, ImPlotRect* self, ImPlotPoint p)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImPlotPoint*, ImPlotRect*, ImPlotPoint, void>)funcTable[16])(pOut, self, p);
			#else
			((delegate* unmanaged[Cdecl]<nint, nint, ImPlotPoint, void>)funcTable[16])((nint)pOut, (nint)self, p);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImPlotPoint Clamp(ImPlotRectPtr self, ImPlotPoint p)
		{
			ImPlotPoint ret;
			ClampNative(&ret, self, p);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Clamp(ImPlotPointPtr pOut, ImPlotRectPtr self, ImPlotPoint p)
		{
			ClampNative(pOut, self, p);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Clamp(ref ImPlotPoint pOut, ImPlotRectPtr self, ImPlotPoint p)
		{
			fixed (ImPlotPoint* ppOut = &pOut)
			{
				ClampNative((ImPlotPoint*)ppOut, self, p);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImPlotPoint Clamp(ref ImPlotRect self, ImPlotPoint p)
		{
			fixed (ImPlotRect* pself = &self)
			{
				ImPlotPoint ret;
				ClampNative(&ret, (ImPlotRect*)pself, p);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Clamp(ImPlotPointPtr pOut, ref ImPlotRect self, ImPlotPoint p)
		{
			fixed (ImPlotRect* pself = &self)
			{
				ClampNative(pOut, (ImPlotRect*)pself, p);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Clamp(ref ImPlotPoint pOut, ref ImPlotRect self, ImPlotPoint p)
		{
			fixed (ImPlotPoint* ppOut = &pOut)
			{
				fixed (ImPlotRect* pself = &self)
				{
					ClampNative((ImPlotPoint*)ppOut, (ImPlotRect*)pself, p);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ClampNative(ImPlotPoint* pOut, ImPlotRect* self, double x, double y)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImPlotPoint*, ImPlotRect*, double, double, void>)funcTable[17])(pOut, self, x, y);
			#else
			((delegate* unmanaged[Cdecl]<nint, nint, double, double, void>)funcTable[17])((nint)pOut, (nint)self, x, y);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImPlotPoint Clamp(ImPlotRectPtr self, double x, double y)
		{
			ImPlotPoint ret;
			ClampNative(&ret, self, x, y);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Clamp(ImPlotPointPtr pOut, ImPlotRectPtr self, double x, double y)
		{
			ClampNative(pOut, self, x, y);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Clamp(ref ImPlotPoint pOut, ImPlotRectPtr self, double x, double y)
		{
			fixed (ImPlotPoint* ppOut = &pOut)
			{
				ClampNative((ImPlotPoint*)ppOut, self, x, y);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImPlotPoint Clamp(ref ImPlotRect self, double x, double y)
		{
			fixed (ImPlotRect* pself = &self)
			{
				ImPlotPoint ret;
				ClampNative(&ret, (ImPlotRect*)pself, x, y);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Clamp(ImPlotPointPtr pOut, ref ImPlotRect self, double x, double y)
		{
			fixed (ImPlotRect* pself = &self)
			{
				ClampNative(pOut, (ImPlotRect*)pself, x, y);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Clamp(ref ImPlotPoint pOut, ref ImPlotRect self, double x, double y)
		{
			fixed (ImPlotPoint* ppOut = &pOut)
			{
				fixed (ImPlotRect* pself = &self)
				{
					ClampNative((ImPlotPoint*)ppOut, (ImPlotRect*)pself, x, y);
				}
			}
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImPlotPoint Min(ImPlotRectPtr self)
		{
			ImPlotPoint ret;
			MinNative(&ret, self);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Min(ImPlotPointPtr pOut, ImPlotRectPtr self)
		{
			MinNative(pOut, self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Min(ref ImPlotPoint pOut, ImPlotRectPtr self)
		{
			fixed (ImPlotPoint* ppOut = &pOut)
			{
				MinNative((ImPlotPoint*)ppOut, self);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImPlotPoint Min(ref ImPlotRect self)
		{
			fixed (ImPlotRect* pself = &self)
			{
				ImPlotPoint ret;
				MinNative(&ret, (ImPlotRect*)pself);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Min(ImPlotPointPtr pOut, ref ImPlotRect self)
		{
			fixed (ImPlotRect* pself = &self)
			{
				MinNative(pOut, (ImPlotRect*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Min(ref ImPlotPoint pOut, ref ImPlotRect self)
		{
			fixed (ImPlotPoint* ppOut = &pOut)
			{
				fixed (ImPlotRect* pself = &self)
				{
					MinNative((ImPlotPoint*)ppOut, (ImPlotRect*)pself);
				}
			}
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImPlotPoint Max(ImPlotRectPtr self)
		{
			ImPlotPoint ret;
			MaxNative(&ret, self);
			return ret;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Max(ImPlotPointPtr pOut, ImPlotRectPtr self)
		{
			MaxNative(pOut, self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Max(ref ImPlotPoint pOut, ImPlotRectPtr self)
		{
			fixed (ImPlotPoint* ppOut = &pOut)
			{
				MaxNative((ImPlotPoint*)ppOut, self);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImPlotPoint Max(ref ImPlotRect self)
		{
			fixed (ImPlotRect* pself = &self)
			{
				ImPlotPoint ret;
				MaxNative(&ret, (ImPlotRect*)pself);
				return ret;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Max(ImPlotPointPtr pOut, ref ImPlotRect self)
		{
			fixed (ImPlotRect* pself = &self)
			{
				MaxNative(pOut, (ImPlotRect*)pself);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Max(ref ImPlotPoint pOut, ref ImPlotRect self)
		{
			fixed (ImPlotPoint* ppOut = &pOut)
			{
				fixed (ImPlotRect* pself = &self)
				{
					MaxNative((ImPlotPoint*)ppOut, (ImPlotRect*)pself);
				}
			}
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImPlotStylePtr ImPlotStyle()
		{
			ImPlotStylePtr ret = ImPlotStyleNative();
			return ret;
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Destroy(ImPlotStylePtr self)
		{
			DestroyNative(self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Destroy(ref ImPlotStyle self)
		{
			fixed (ImPlotStyle* pself = &self)
			{
				DestroyNative((ImPlotStyle*)pself);
			}
		}

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

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

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Destroy(ImPlotInputMapPtr self)
		{
			DestroyNative(self);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void Destroy(ref ImPlotInputMap self)
		{
			fixed (ImPlotInputMap* pself = &self)
			{
				DestroyNative((ImPlotInputMap*)pself);
			}
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImPlotContextPtr CreateContext()
		{
			ImPlotContextPtr ret = CreateContextNative();
			return ret;
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DestroyContext(ImPlotContextPtr ctx)
		{
			DestroyContextNative(ctx);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DestroyContext()
		{
			DestroyContextNative((ImPlotContext*)(((void*)0)));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void DestroyContext(ref ImPlotContext ctx)
		{
			fixed (ImPlotContext* pctx = &ctx)
			{
				DestroyContextNative((ImPlotContext*)pctx);
			}
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static ImPlotContextPtr GetCurrentContext()
		{
			ImPlotContextPtr ret = GetCurrentContextNative();
			return ret;
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetCurrentContext(ImPlotContextPtr ctx)
		{
			SetCurrentContextNative(ctx);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetCurrentContext(ref ImPlotContext ctx)
		{
			fixed (ImPlotContext* pctx = &ctx)
			{
				SetCurrentContextNative((ImPlotContext*)pctx);
			}
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetImGuiContext(ImGuiContextPtr ctx)
		{
			SetImGuiContextNative(ctx);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetImGuiContext(ref ImGuiContext ctx)
		{
			fixed (ImGuiContext* pctx = &ctx)
			{
				SetImGuiContextNative((ImGuiContext*)pctx);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte BeginPlotNative(byte* titleId, Vector2 size, ImPlotFlags flags)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<byte*, Vector2, ImPlotFlags, byte>)funcTable[29])(titleId, size, flags);
			#else
			return (byte)((delegate* unmanaged[Cdecl]<nint, Vector2, ImPlotFlags, byte>)funcTable[29])((nint)titleId, size, flags);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginPlot(byte* titleId, Vector2 size, ImPlotFlags flags)
		{
			byte ret = BeginPlotNative(titleId, size, flags);
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginPlot(byte* titleId, Vector2 size)
		{
			byte ret = BeginPlotNative(titleId, size, (ImPlotFlags)(0));
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginPlot(byte* titleId)
		{
			byte ret = BeginPlotNative(titleId, (Vector2)(new Vector2(-1,0)), (ImPlotFlags)(0));
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginPlot(byte* titleId, ImPlotFlags flags)
		{
			byte ret = BeginPlotNative(titleId, (Vector2)(new Vector2(-1,0)), flags);
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginPlot(ref byte titleId, Vector2 size, ImPlotFlags flags)
		{
			fixed (byte* ptitleId = &titleId)
			{
				byte ret = BeginPlotNative((byte*)ptitleId, size, flags);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginPlot(ref byte titleId, Vector2 size)
		{
			fixed (byte* ptitleId = &titleId)
			{
				byte ret = BeginPlotNative((byte*)ptitleId, size, (ImPlotFlags)(0));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginPlot(ref byte titleId)
		{
			fixed (byte* ptitleId = &titleId)
			{
				byte ret = BeginPlotNative((byte*)ptitleId, (Vector2)(new Vector2(-1,0)), (ImPlotFlags)(0));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginPlot(ref byte titleId, ImPlotFlags flags)
		{
			fixed (byte* ptitleId = &titleId)
			{
				byte ret = BeginPlotNative((byte*)ptitleId, (Vector2)(new Vector2(-1,0)), flags);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginPlot(ReadOnlySpan<byte> titleId, Vector2 size, ImPlotFlags flags)
		{
			fixed (byte* ptitleId = titleId)
			{
				byte ret = BeginPlotNative((byte*)ptitleId, size, flags);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginPlot(ReadOnlySpan<byte> titleId, Vector2 size)
		{
			fixed (byte* ptitleId = titleId)
			{
				byte ret = BeginPlotNative((byte*)ptitleId, size, (ImPlotFlags)(0));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginPlot(ReadOnlySpan<byte> titleId)
		{
			fixed (byte* ptitleId = titleId)
			{
				byte ret = BeginPlotNative((byte*)ptitleId, (Vector2)(new Vector2(-1,0)), (ImPlotFlags)(0));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginPlot(ReadOnlySpan<byte> titleId, ImPlotFlags flags)
		{
			fixed (byte* ptitleId = titleId)
			{
				byte ret = BeginPlotNative((byte*)ptitleId, (Vector2)(new Vector2(-1,0)), flags);
				return ret != 0;
			}
		}

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

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

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

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

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

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

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static byte BeginSubplotsNative(byte* titleId, int rows, int cols, Vector2 size, ImPlotSubplotFlags flags, float* rowRatios, float* colRatios)
		{
			#if NET5_0_OR_GREATER
			return ((delegate* unmanaged[Cdecl]<byte*, int, int, Vector2, ImPlotSubplotFlags, float*, float*, byte>)funcTable[31])(titleId, rows, cols, size, flags, rowRatios, colRatios);
			#else
			return (byte)((delegate* unmanaged[Cdecl]<nint, int, int, Vector2, ImPlotSubplotFlags, nint, nint, byte>)funcTable[31])((nint)titleId, rows, cols, size, flags, (nint)rowRatios, (nint)colRatios);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(byte* titleId, int rows, int cols, Vector2 size, ImPlotSubplotFlags flags, float* rowRatios, float* colRatios)
		{
			byte ret = BeginSubplotsNative(titleId, rows, cols, size, flags, rowRatios, colRatios);
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(byte* titleId, int rows, int cols, Vector2 size, ImPlotSubplotFlags flags, float* rowRatios)
		{
			byte ret = BeginSubplotsNative(titleId, rows, cols, size, flags, rowRatios, (float*)(((void*)0)));
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(byte* titleId, int rows, int cols, Vector2 size, ImPlotSubplotFlags flags)
		{
			byte ret = BeginSubplotsNative(titleId, rows, cols, size, flags, (float*)(((void*)0)), (float*)(((void*)0)));
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(byte* titleId, int rows, int cols, Vector2 size)
		{
			byte ret = BeginSubplotsNative(titleId, rows, cols, size, (ImPlotSubplotFlags)(0), (float*)(((void*)0)), (float*)(((void*)0)));
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(byte* titleId, int rows, int cols, Vector2 size, float* rowRatios)
		{
			byte ret = BeginSubplotsNative(titleId, rows, cols, size, (ImPlotSubplotFlags)(0), rowRatios, (float*)(((void*)0)));
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(byte* titleId, int rows, int cols, Vector2 size, float* rowRatios, float* colRatios)
		{
			byte ret = BeginSubplotsNative(titleId, rows, cols, size, (ImPlotSubplotFlags)(0), rowRatios, colRatios);
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(ref byte titleId, int rows, int cols, Vector2 size, ImPlotSubplotFlags flags, float* rowRatios, float* colRatios)
		{
			fixed (byte* ptitleId = &titleId)
			{
				byte ret = BeginSubplotsNative((byte*)ptitleId, rows, cols, size, flags, rowRatios, colRatios);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(ref byte titleId, int rows, int cols, Vector2 size, ImPlotSubplotFlags flags, float* rowRatios)
		{
			fixed (byte* ptitleId = &titleId)
			{
				byte ret = BeginSubplotsNative((byte*)ptitleId, rows, cols, size, flags, rowRatios, (float*)(((void*)0)));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(ref byte titleId, int rows, int cols, Vector2 size, ImPlotSubplotFlags flags)
		{
			fixed (byte* ptitleId = &titleId)
			{
				byte ret = BeginSubplotsNative((byte*)ptitleId, rows, cols, size, flags, (float*)(((void*)0)), (float*)(((void*)0)));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(ref byte titleId, int rows, int cols, Vector2 size)
		{
			fixed (byte* ptitleId = &titleId)
			{
				byte ret = BeginSubplotsNative((byte*)ptitleId, rows, cols, size, (ImPlotSubplotFlags)(0), (float*)(((void*)0)), (float*)(((void*)0)));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(ref byte titleId, int rows, int cols, Vector2 size, float* rowRatios)
		{
			fixed (byte* ptitleId = &titleId)
			{
				byte ret = BeginSubplotsNative((byte*)ptitleId, rows, cols, size, (ImPlotSubplotFlags)(0), rowRatios, (float*)(((void*)0)));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(ref byte titleId, int rows, int cols, Vector2 size, float* rowRatios, float* colRatios)
		{
			fixed (byte* ptitleId = &titleId)
			{
				byte ret = BeginSubplotsNative((byte*)ptitleId, rows, cols, size, (ImPlotSubplotFlags)(0), rowRatios, colRatios);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(ReadOnlySpan<byte> titleId, int rows, int cols, Vector2 size, ImPlotSubplotFlags flags, float* rowRatios, float* colRatios)
		{
			fixed (byte* ptitleId = titleId)
			{
				byte ret = BeginSubplotsNative((byte*)ptitleId, rows, cols, size, flags, rowRatios, colRatios);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(ReadOnlySpan<byte> titleId, int rows, int cols, Vector2 size, ImPlotSubplotFlags flags, float* rowRatios)
		{
			fixed (byte* ptitleId = titleId)
			{
				byte ret = BeginSubplotsNative((byte*)ptitleId, rows, cols, size, flags, rowRatios, (float*)(((void*)0)));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(ReadOnlySpan<byte> titleId, int rows, int cols, Vector2 size, ImPlotSubplotFlags flags)
		{
			fixed (byte* ptitleId = titleId)
			{
				byte ret = BeginSubplotsNative((byte*)ptitleId, rows, cols, size, flags, (float*)(((void*)0)), (float*)(((void*)0)));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(ReadOnlySpan<byte> titleId, int rows, int cols, Vector2 size)
		{
			fixed (byte* ptitleId = titleId)
			{
				byte ret = BeginSubplotsNative((byte*)ptitleId, rows, cols, size, (ImPlotSubplotFlags)(0), (float*)(((void*)0)), (float*)(((void*)0)));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(ReadOnlySpan<byte> titleId, int rows, int cols, Vector2 size, float* rowRatios)
		{
			fixed (byte* ptitleId = titleId)
			{
				byte ret = BeginSubplotsNative((byte*)ptitleId, rows, cols, size, (ImPlotSubplotFlags)(0), rowRatios, (float*)(((void*)0)));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(ReadOnlySpan<byte> titleId, int rows, int cols, Vector2 size, float* rowRatios, float* colRatios)
		{
			fixed (byte* ptitleId = titleId)
			{
				byte ret = BeginSubplotsNative((byte*)ptitleId, rows, cols, size, (ImPlotSubplotFlags)(0), rowRatios, colRatios);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(string titleId, int rows, int cols, Vector2 size, ImPlotSubplotFlags flags, float* rowRatios, float* colRatios)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (titleId != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(titleId);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(titleId, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			byte ret = BeginSubplotsNative(pStr0, rows, cols, size, flags, rowRatios, colRatios);
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(string titleId, int rows, int cols, Vector2 size, ImPlotSubplotFlags flags, float* rowRatios)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (titleId != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(titleId);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(titleId, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			byte ret = BeginSubplotsNative(pStr0, rows, cols, size, flags, rowRatios, (float*)(((void*)0)));
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(string titleId, int rows, int cols, Vector2 size, ImPlotSubplotFlags flags)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (titleId != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(titleId);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(titleId, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			byte ret = BeginSubplotsNative(pStr0, rows, cols, size, flags, (float*)(((void*)0)), (float*)(((void*)0)));
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(string titleId, int rows, int cols, Vector2 size)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (titleId != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(titleId);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(titleId, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			byte ret = BeginSubplotsNative(pStr0, rows, cols, size, (ImPlotSubplotFlags)(0), (float*)(((void*)0)), (float*)(((void*)0)));
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(string titleId, int rows, int cols, Vector2 size, float* rowRatios)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (titleId != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(titleId);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(titleId, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			byte ret = BeginSubplotsNative(pStr0, rows, cols, size, (ImPlotSubplotFlags)(0), rowRatios, (float*)(((void*)0)));
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(string titleId, int rows, int cols, Vector2 size, float* rowRatios, float* colRatios)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (titleId != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(titleId);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(titleId, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			byte ret = BeginSubplotsNative(pStr0, rows, cols, size, (ImPlotSubplotFlags)(0), rowRatios, colRatios);
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
			return ret != 0;
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(byte* titleId, int rows, int cols, Vector2 size, ImPlotSubplotFlags flags, ref float rowRatios, float* colRatios)
		{
			fixed (float* prowRatios = &rowRatios)
			{
				byte ret = BeginSubplotsNative(titleId, rows, cols, size, flags, (float*)prowRatios, colRatios);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(byte* titleId, int rows, int cols, Vector2 size, ImPlotSubplotFlags flags, ref float rowRatios)
		{
			fixed (float* prowRatios = &rowRatios)
			{
				byte ret = BeginSubplotsNative(titleId, rows, cols, size, flags, (float*)prowRatios, (float*)(((void*)0)));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(byte* titleId, int rows, int cols, Vector2 size, ref float rowRatios)
		{
			fixed (float* prowRatios = &rowRatios)
			{
				byte ret = BeginSubplotsNative(titleId, rows, cols, size, (ImPlotSubplotFlags)(0), (float*)prowRatios, (float*)(((void*)0)));
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(byte* titleId, int rows, int cols, Vector2 size, ref float rowRatios, float* colRatios)
		{
			fixed (float* prowRatios = &rowRatios)
			{
				byte ret = BeginSubplotsNative(titleId, rows, cols, size, (ImPlotSubplotFlags)(0), (float*)prowRatios, colRatios);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(ref byte titleId, int rows, int cols, Vector2 size, ImPlotSubplotFlags flags, ref float rowRatios, float* colRatios)
		{
			fixed (byte* ptitleId = &titleId)
			{
				fixed (float* prowRatios = &rowRatios)
				{
					byte ret = BeginSubplotsNative((byte*)ptitleId, rows, cols, size, flags, (float*)prowRatios, colRatios);
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(ref byte titleId, int rows, int cols, Vector2 size, ImPlotSubplotFlags flags, ref float rowRatios)
		{
			fixed (byte* ptitleId = &titleId)
			{
				fixed (float* prowRatios = &rowRatios)
				{
					byte ret = BeginSubplotsNative((byte*)ptitleId, rows, cols, size, flags, (float*)prowRatios, (float*)(((void*)0)));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(ref byte titleId, int rows, int cols, Vector2 size, ref float rowRatios)
		{
			fixed (byte* ptitleId = &titleId)
			{
				fixed (float* prowRatios = &rowRatios)
				{
					byte ret = BeginSubplotsNative((byte*)ptitleId, rows, cols, size, (ImPlotSubplotFlags)(0), (float*)prowRatios, (float*)(((void*)0)));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(ref byte titleId, int rows, int cols, Vector2 size, ref float rowRatios, float* colRatios)
		{
			fixed (byte* ptitleId = &titleId)
			{
				fixed (float* prowRatios = &rowRatios)
				{
					byte ret = BeginSubplotsNative((byte*)ptitleId, rows, cols, size, (ImPlotSubplotFlags)(0), (float*)prowRatios, colRatios);
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(ReadOnlySpan<byte> titleId, int rows, int cols, Vector2 size, ImPlotSubplotFlags flags, ref float rowRatios, float* colRatios)
		{
			fixed (byte* ptitleId = titleId)
			{
				fixed (float* prowRatios = &rowRatios)
				{
					byte ret = BeginSubplotsNative((byte*)ptitleId, rows, cols, size, flags, (float*)prowRatios, colRatios);
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(ReadOnlySpan<byte> titleId, int rows, int cols, Vector2 size, ImPlotSubplotFlags flags, ref float rowRatios)
		{
			fixed (byte* ptitleId = titleId)
			{
				fixed (float* prowRatios = &rowRatios)
				{
					byte ret = BeginSubplotsNative((byte*)ptitleId, rows, cols, size, flags, (float*)prowRatios, (float*)(((void*)0)));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(ReadOnlySpan<byte> titleId, int rows, int cols, Vector2 size, ref float rowRatios)
		{
			fixed (byte* ptitleId = titleId)
			{
				fixed (float* prowRatios = &rowRatios)
				{
					byte ret = BeginSubplotsNative((byte*)ptitleId, rows, cols, size, (ImPlotSubplotFlags)(0), (float*)prowRatios, (float*)(((void*)0)));
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(ReadOnlySpan<byte> titleId, int rows, int cols, Vector2 size, ref float rowRatios, float* colRatios)
		{
			fixed (byte* ptitleId = titleId)
			{
				fixed (float* prowRatios = &rowRatios)
				{
					byte ret = BeginSubplotsNative((byte*)ptitleId, rows, cols, size, (ImPlotSubplotFlags)(0), (float*)prowRatios, colRatios);
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(string titleId, int rows, int cols, Vector2 size, ImPlotSubplotFlags flags, ref float rowRatios, float* colRatios)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (titleId != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(titleId);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(titleId, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (float* prowRatios = &rowRatios)
			{
				byte ret = BeginSubplotsNative(pStr0, rows, cols, size, flags, (float*)prowRatios, colRatios);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(string titleId, int rows, int cols, Vector2 size, ImPlotSubplotFlags flags, ref float rowRatios)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (titleId != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(titleId);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(titleId, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (float* prowRatios = &rowRatios)
			{
				byte ret = BeginSubplotsNative(pStr0, rows, cols, size, flags, (float*)prowRatios, (float*)(((void*)0)));
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(string titleId, int rows, int cols, Vector2 size, ref float rowRatios)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (titleId != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(titleId);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(titleId, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (float* prowRatios = &rowRatios)
			{
				byte ret = BeginSubplotsNative(pStr0, rows, cols, size, (ImPlotSubplotFlags)(0), (float*)prowRatios, (float*)(((void*)0)));
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(string titleId, int rows, int cols, Vector2 size, ref float rowRatios, float* colRatios)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (titleId != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(titleId);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(titleId, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (float* prowRatios = &rowRatios)
			{
				byte ret = BeginSubplotsNative(pStr0, rows, cols, size, (ImPlotSubplotFlags)(0), (float*)prowRatios, colRatios);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(byte* titleId, int rows, int cols, Vector2 size, ImPlotSubplotFlags flags, float* rowRatios, ref float colRatios)
		{
			fixed (float* pcolRatios = &colRatios)
			{
				byte ret = BeginSubplotsNative(titleId, rows, cols, size, flags, rowRatios, (float*)pcolRatios);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(byte* titleId, int rows, int cols, Vector2 size, float* rowRatios, ref float colRatios)
		{
			fixed (float* pcolRatios = &colRatios)
			{
				byte ret = BeginSubplotsNative(titleId, rows, cols, size, (ImPlotSubplotFlags)(0), rowRatios, (float*)pcolRatios);
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(ref byte titleId, int rows, int cols, Vector2 size, ImPlotSubplotFlags flags, float* rowRatios, ref float colRatios)
		{
			fixed (byte* ptitleId = &titleId)
			{
				fixed (float* pcolRatios = &colRatios)
				{
					byte ret = BeginSubplotsNative((byte*)ptitleId, rows, cols, size, flags, rowRatios, (float*)pcolRatios);
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(ref byte titleId, int rows, int cols, Vector2 size, float* rowRatios, ref float colRatios)
		{
			fixed (byte* ptitleId = &titleId)
			{
				fixed (float* pcolRatios = &colRatios)
				{
					byte ret = BeginSubplotsNative((byte*)ptitleId, rows, cols, size, (ImPlotSubplotFlags)(0), rowRatios, (float*)pcolRatios);
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(ReadOnlySpan<byte> titleId, int rows, int cols, Vector2 size, ImPlotSubplotFlags flags, float* rowRatios, ref float colRatios)
		{
			fixed (byte* ptitleId = titleId)
			{
				fixed (float* pcolRatios = &colRatios)
				{
					byte ret = BeginSubplotsNative((byte*)ptitleId, rows, cols, size, flags, rowRatios, (float*)pcolRatios);
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(ReadOnlySpan<byte> titleId, int rows, int cols, Vector2 size, float* rowRatios, ref float colRatios)
		{
			fixed (byte* ptitleId = titleId)
			{
				fixed (float* pcolRatios = &colRatios)
				{
					byte ret = BeginSubplotsNative((byte*)ptitleId, rows, cols, size, (ImPlotSubplotFlags)(0), rowRatios, (float*)pcolRatios);
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(string titleId, int rows, int cols, Vector2 size, ImPlotSubplotFlags flags, float* rowRatios, ref float colRatios)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (titleId != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(titleId);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(titleId, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (float* pcolRatios = &colRatios)
			{
				byte ret = BeginSubplotsNative(pStr0, rows, cols, size, flags, rowRatios, (float*)pcolRatios);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(string titleId, int rows, int cols, Vector2 size, float* rowRatios, ref float colRatios)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (titleId != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(titleId);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(titleId, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (float* pcolRatios = &colRatios)
			{
				byte ret = BeginSubplotsNative(pStr0, rows, cols, size, (ImPlotSubplotFlags)(0), rowRatios, (float*)pcolRatios);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
				return ret != 0;
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(byte* titleId, int rows, int cols, Vector2 size, ImPlotSubplotFlags flags, ref float rowRatios, ref float colRatios)
		{
			fixed (float* prowRatios = &rowRatios)
			{
				fixed (float* pcolRatios = &colRatios)
				{
					byte ret = BeginSubplotsNative(titleId, rows, cols, size, flags, (float*)prowRatios, (float*)pcolRatios);
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(byte* titleId, int rows, int cols, Vector2 size, ref float rowRatios, ref float colRatios)
		{
			fixed (float* prowRatios = &rowRatios)
			{
				fixed (float* pcolRatios = &colRatios)
				{
					byte ret = BeginSubplotsNative(titleId, rows, cols, size, (ImPlotSubplotFlags)(0), (float*)prowRatios, (float*)pcolRatios);
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(ref byte titleId, int rows, int cols, Vector2 size, ImPlotSubplotFlags flags, ref float rowRatios, ref float colRatios)
		{
			fixed (byte* ptitleId = &titleId)
			{
				fixed (float* prowRatios = &rowRatios)
				{
					fixed (float* pcolRatios = &colRatios)
					{
						byte ret = BeginSubplotsNative((byte*)ptitleId, rows, cols, size, flags, (float*)prowRatios, (float*)pcolRatios);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(ref byte titleId, int rows, int cols, Vector2 size, ref float rowRatios, ref float colRatios)
		{
			fixed (byte* ptitleId = &titleId)
			{
				fixed (float* prowRatios = &rowRatios)
				{
					fixed (float* pcolRatios = &colRatios)
					{
						byte ret = BeginSubplotsNative((byte*)ptitleId, rows, cols, size, (ImPlotSubplotFlags)(0), (float*)prowRatios, (float*)pcolRatios);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(ReadOnlySpan<byte> titleId, int rows, int cols, Vector2 size, ImPlotSubplotFlags flags, ref float rowRatios, ref float colRatios)
		{
			fixed (byte* ptitleId = titleId)
			{
				fixed (float* prowRatios = &rowRatios)
				{
					fixed (float* pcolRatios = &colRatios)
					{
						byte ret = BeginSubplotsNative((byte*)ptitleId, rows, cols, size, flags, (float*)prowRatios, (float*)pcolRatios);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(ReadOnlySpan<byte> titleId, int rows, int cols, Vector2 size, ref float rowRatios, ref float colRatios)
		{
			fixed (byte* ptitleId = titleId)
			{
				fixed (float* prowRatios = &rowRatios)
				{
					fixed (float* pcolRatios = &colRatios)
					{
						byte ret = BeginSubplotsNative((byte*)ptitleId, rows, cols, size, (ImPlotSubplotFlags)(0), (float*)prowRatios, (float*)pcolRatios);
						return ret != 0;
					}
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(string titleId, int rows, int cols, Vector2 size, ImPlotSubplotFlags flags, ref float rowRatios, ref float colRatios)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (titleId != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(titleId);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(titleId, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (float* prowRatios = &rowRatios)
			{
				fixed (float* pcolRatios = &colRatios)
				{
					byte ret = BeginSubplotsNative(pStr0, rows, cols, size, flags, (float*)prowRatios, (float*)pcolRatios);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						Utils.Free(pStr0);
					}
					return ret != 0;
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static bool BeginSubplots(string titleId, int rows, int cols, Vector2 size, ref float rowRatios, ref float colRatios)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (titleId != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(titleId);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(titleId, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (float* prowRatios = &rowRatios)
			{
				fixed (float* pcolRatios = &colRatios)
				{
					byte ret = BeginSubplotsNative(pStr0, rows, cols, size, (ImPlotSubplotFlags)(0), (float*)prowRatios, (float*)pcolRatios);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						Utils.Free(pStr0);
					}
					return ret != 0;
				}
			}
		}

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

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

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SetupAxisNative(ImAxis axis, byte* label, ImPlotAxisFlags flags)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImAxis, byte*, ImPlotAxisFlags, void>)funcTable[33])(axis, label, flags);
			#else
			((delegate* unmanaged[Cdecl]<ImAxis, nint, ImPlotAxisFlags, void>)funcTable[33])(axis, (nint)label, flags);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxis(ImAxis axis, byte* label, ImPlotAxisFlags flags)
		{
			SetupAxisNative(axis, label, flags);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxis(ImAxis axis, byte* label)
		{
			SetupAxisNative(axis, label, (ImPlotAxisFlags)(0));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxis(ImAxis axis)
		{
			SetupAxisNative(axis, (byte*)(((void*)0)), (ImPlotAxisFlags)(0));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxis(ImAxis axis, ImPlotAxisFlags flags)
		{
			SetupAxisNative(axis, (byte*)(((void*)0)), flags);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxis(ImAxis axis, ref byte label, ImPlotAxisFlags flags)
		{
			fixed (byte* plabel = &label)
			{
				SetupAxisNative(axis, (byte*)plabel, flags);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxis(ImAxis axis, ref byte label)
		{
			fixed (byte* plabel = &label)
			{
				SetupAxisNative(axis, (byte*)plabel, (ImPlotAxisFlags)(0));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxis(ImAxis axis, ReadOnlySpan<byte> label, ImPlotAxisFlags flags)
		{
			fixed (byte* plabel = label)
			{
				SetupAxisNative(axis, (byte*)plabel, flags);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxis(ImAxis axis, ReadOnlySpan<byte> label)
		{
			fixed (byte* plabel = label)
			{
				SetupAxisNative(axis, (byte*)plabel, (ImPlotAxisFlags)(0));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxis(ImAxis axis, string label, ImPlotAxisFlags flags)
		{
			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;
			}
			SetupAxisNative(axis, pStr0, flags);
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxis(ImAxis axis, 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;
			}
			SetupAxisNative(axis, pStr0, (ImPlotAxisFlags)(0));
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SetupAxisLimitsNative(ImAxis axis, double vMin, double vMax, ImPlotCond cond)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImAxis, double, double, ImPlotCond, void>)funcTable[34])(axis, vMin, vMax, cond);
			#else
			((delegate* unmanaged[Cdecl]<ImAxis, double, double, ImPlotCond, void>)funcTable[34])(axis, vMin, vMax, cond);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxisLimits(ImAxis axis, double vMin, double vMax, ImPlotCond cond)
		{
			SetupAxisLimitsNative(axis, vMin, vMax, cond);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxisLimits(ImAxis axis, double vMin, double vMax)
		{
			SetupAxisLimitsNative(axis, vMin, vMax, (ImPlotCond)(ImPlotCond.Once));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SetupAxisLinksNative(ImAxis axis, double* linkMin, double* linkMax)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImAxis, double*, double*, void>)funcTable[35])(axis, linkMin, linkMax);
			#else
			((delegate* unmanaged[Cdecl]<ImAxis, nint, nint, void>)funcTable[35])(axis, (nint)linkMin, (nint)linkMax);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxisLinks(ImAxis axis, double* linkMin, double* linkMax)
		{
			SetupAxisLinksNative(axis, linkMin, linkMax);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxisLinks(ImAxis axis, ref double linkMin, double* linkMax)
		{
			fixed (double* plinkMin = &linkMin)
			{
				SetupAxisLinksNative(axis, (double*)plinkMin, linkMax);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxisLinks(ImAxis axis, double* linkMin, ref double linkMax)
		{
			fixed (double* plinkMax = &linkMax)
			{
				SetupAxisLinksNative(axis, linkMin, (double*)plinkMax);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxisLinks(ImAxis axis, ref double linkMin, ref double linkMax)
		{
			fixed (double* plinkMin = &linkMin)
			{
				fixed (double* plinkMax = &linkMax)
				{
					SetupAxisLinksNative(axis, (double*)plinkMin, (double*)plinkMax);
				}
			}
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxisFormat(ImAxis axis, byte* fmt)
		{
			SetupAxisFormatNative(axis, fmt);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxisFormat(ImAxis axis, ref byte fmt)
		{
			fixed (byte* pfmt = &fmt)
			{
				SetupAxisFormatNative(axis, (byte*)pfmt);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxisFormat(ImAxis axis, ReadOnlySpan<byte> fmt)
		{
			fixed (byte* pfmt = fmt)
			{
				SetupAxisFormatNative(axis, (byte*)pfmt);
			}
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SetupAxisFormatNative(ImAxis axis, ImPlotFormatter formatter, void* data)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImAxis, delegate*<double, byte*, int, void*, int>, void*, void>)funcTable[37])(axis, (delegate*<double, byte*, int, void*, int>)Utils.GetFunctionPointerForDelegate(formatter), data);
			#else
			((delegate* unmanaged[Cdecl]<ImAxis, nint, nint, void>)funcTable[37])(axis, (nint)Utils.GetFunctionPointerForDelegate(formatter), (nint)data);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxisFormat(ImAxis axis, ImPlotFormatter formatter, void* data)
		{
			SetupAxisFormatNative(axis, formatter, data);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxisFormat(ImAxis axis, ImPlotFormatter formatter)
		{
			SetupAxisFormatNative(axis, formatter, (void*)(((void*)0)));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SetupAxisTicksNative(ImAxis axis, double* values, int nTicks, byte** labels, byte keepDefault)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImAxis, double*, int, byte**, byte, void>)funcTable[38])(axis, values, nTicks, labels, keepDefault);
			#else
			((delegate* unmanaged[Cdecl]<ImAxis, nint, int, nint, byte, void>)funcTable[38])(axis, (nint)values, nTicks, (nint)labels, keepDefault);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxisTicks(ImAxis axis, double* values, int nTicks, byte** labels, bool keepDefault)
		{
			SetupAxisTicksNative(axis, values, nTicks, labels, keepDefault ? (byte)1 : (byte)0);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxisTicks(ImAxis axis, double* values, int nTicks, byte** labels)
		{
			SetupAxisTicksNative(axis, values, nTicks, labels, (byte)(0));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxisTicks(ImAxis axis, double* values, int nTicks)
		{
			SetupAxisTicksNative(axis, values, nTicks, (byte**)(((void*)0)), (byte)(0));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxisTicks(ImAxis axis, double* values, int nTicks, bool keepDefault)
		{
			SetupAxisTicksNative(axis, values, nTicks, (byte**)(((void*)0)), keepDefault ? (byte)1 : (byte)0);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxisTicks(ImAxis axis, ref double values, int nTicks, byte** labels, bool keepDefault)
		{
			fixed (double* pvalues = &values)
			{
				SetupAxisTicksNative(axis, (double*)pvalues, nTicks, labels, keepDefault ? (byte)1 : (byte)0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxisTicks(ImAxis axis, ref double values, int nTicks, byte** labels)
		{
			fixed (double* pvalues = &values)
			{
				SetupAxisTicksNative(axis, (double*)pvalues, nTicks, labels, (byte)(0));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxisTicks(ImAxis axis, ref double values, int nTicks)
		{
			fixed (double* pvalues = &values)
			{
				SetupAxisTicksNative(axis, (double*)pvalues, nTicks, (byte**)(((void*)0)), (byte)(0));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxisTicks(ImAxis axis, ref double values, int nTicks, bool keepDefault)
		{
			fixed (double* pvalues = &values)
			{
				SetupAxisTicksNative(axis, (double*)pvalues, nTicks, (byte**)(((void*)0)), keepDefault ? (byte)1 : (byte)0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxisTicks(ImAxis axis, double* values, int nTicks, string[] labels, bool keepDefault)
		{
			byte** pStrArray0 = null;
			int pStrArray0Size = Utils.GetByteCountArray(labels);
			if (labels != null)
			{
				if (pStrArray0Size > Utils.MaxStackallocSize)
				{
					pStrArray0 = (byte**)Utils.Alloc<byte>(pStrArray0Size);
				}
				else
				{
					byte* pStrArray0Stack = stackalloc byte[pStrArray0Size];
					pStrArray0 = (byte**)pStrArray0Stack;
				}
			}
			for (int i = 0; i < labels.Length; i++)
			{
				pStrArray0[i] = (byte*)Utils.StringToUTF8Ptr(labels[i]);
			}
			SetupAxisTicksNative(axis, values, nTicks, pStrArray0, keepDefault ? (byte)1 : (byte)0);
			for (int i = 0; i < labels.Length; i++)
			{
				Utils.Free(pStrArray0[i]);
			}
			if (pStrArray0Size >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStrArray0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxisTicks(ImAxis axis, double* values, int nTicks, string[] labels)
		{
			byte** pStrArray0 = null;
			int pStrArray0Size = Utils.GetByteCountArray(labels);
			if (labels != null)
			{
				if (pStrArray0Size > Utils.MaxStackallocSize)
				{
					pStrArray0 = (byte**)Utils.Alloc<byte>(pStrArray0Size);
				}
				else
				{
					byte* pStrArray0Stack = stackalloc byte[pStrArray0Size];
					pStrArray0 = (byte**)pStrArray0Stack;
				}
			}
			for (int i = 0; i < labels.Length; i++)
			{
				pStrArray0[i] = (byte*)Utils.StringToUTF8Ptr(labels[i]);
			}
			SetupAxisTicksNative(axis, values, nTicks, pStrArray0, (byte)(0));
			for (int i = 0; i < labels.Length; i++)
			{
				Utils.Free(pStrArray0[i]);
			}
			if (pStrArray0Size >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStrArray0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxisTicks(ImAxis axis, ref double values, int nTicks, string[] labels, bool keepDefault)
		{
			fixed (double* pvalues = &values)
			{
				byte** pStrArray0 = null;
				int pStrArray0Size = Utils.GetByteCountArray(labels);
				if (labels != null)
				{
					if (pStrArray0Size > Utils.MaxStackallocSize)
					{
						pStrArray0 = (byte**)Utils.Alloc<byte>(pStrArray0Size);
					}
					else
					{
						byte* pStrArray0Stack = stackalloc byte[pStrArray0Size];
						pStrArray0 = (byte**)pStrArray0Stack;
					}
				}
				for (int i = 0; i < labels.Length; i++)
				{
					pStrArray0[i] = (byte*)Utils.StringToUTF8Ptr(labels[i]);
				}
				SetupAxisTicksNative(axis, (double*)pvalues, nTicks, pStrArray0, keepDefault ? (byte)1 : (byte)0);
				for (int i = 0; i < labels.Length; i++)
				{
					Utils.Free(pStrArray0[i]);
				}
				if (pStrArray0Size >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStrArray0);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxisTicks(ImAxis axis, ref double values, int nTicks, string[] labels)
		{
			fixed (double* pvalues = &values)
			{
				byte** pStrArray0 = null;
				int pStrArray0Size = Utils.GetByteCountArray(labels);
				if (labels != null)
				{
					if (pStrArray0Size > Utils.MaxStackallocSize)
					{
						pStrArray0 = (byte**)Utils.Alloc<byte>(pStrArray0Size);
					}
					else
					{
						byte* pStrArray0Stack = stackalloc byte[pStrArray0Size];
						pStrArray0 = (byte**)pStrArray0Stack;
					}
				}
				for (int i = 0; i < labels.Length; i++)
				{
					pStrArray0[i] = (byte*)Utils.StringToUTF8Ptr(labels[i]);
				}
				SetupAxisTicksNative(axis, (double*)pvalues, nTicks, pStrArray0, (byte)(0));
				for (int i = 0; i < labels.Length; i++)
				{
					Utils.Free(pStrArray0[i]);
				}
				if (pStrArray0Size >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStrArray0);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SetupAxisTicksNative(ImAxis axis, double vMin, double vMax, int nTicks, byte** labels, byte keepDefault)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImAxis, double, double, int, byte**, byte, void>)funcTable[39])(axis, vMin, vMax, nTicks, labels, keepDefault);
			#else
			((delegate* unmanaged[Cdecl]<ImAxis, double, double, int, nint, byte, void>)funcTable[39])(axis, vMin, vMax, nTicks, (nint)labels, keepDefault);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxisTicks(ImAxis axis, double vMin, double vMax, int nTicks, byte** labels, bool keepDefault)
		{
			SetupAxisTicksNative(axis, vMin, vMax, nTicks, labels, keepDefault ? (byte)1 : (byte)0);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxisTicks(ImAxis axis, double vMin, double vMax, int nTicks, byte** labels)
		{
			SetupAxisTicksNative(axis, vMin, vMax, nTicks, labels, (byte)(0));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxisTicks(ImAxis axis, double vMin, double vMax, int nTicks)
		{
			SetupAxisTicksNative(axis, vMin, vMax, nTicks, (byte**)(((void*)0)), (byte)(0));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxisTicks(ImAxis axis, double vMin, double vMax, int nTicks, bool keepDefault)
		{
			SetupAxisTicksNative(axis, vMin, vMax, nTicks, (byte**)(((void*)0)), keepDefault ? (byte)1 : (byte)0);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxisTicks(ImAxis axis, double vMin, double vMax, int nTicks, string[] labels, bool keepDefault)
		{
			byte** pStrArray0 = null;
			int pStrArray0Size = Utils.GetByteCountArray(labels);
			if (labels != null)
			{
				if (pStrArray0Size > Utils.MaxStackallocSize)
				{
					pStrArray0 = (byte**)Utils.Alloc<byte>(pStrArray0Size);
				}
				else
				{
					byte* pStrArray0Stack = stackalloc byte[pStrArray0Size];
					pStrArray0 = (byte**)pStrArray0Stack;
				}
			}
			for (int i = 0; i < labels.Length; i++)
			{
				pStrArray0[i] = (byte*)Utils.StringToUTF8Ptr(labels[i]);
			}
			SetupAxisTicksNative(axis, vMin, vMax, nTicks, pStrArray0, keepDefault ? (byte)1 : (byte)0);
			for (int i = 0; i < labels.Length; i++)
			{
				Utils.Free(pStrArray0[i]);
			}
			if (pStrArray0Size >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStrArray0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxisTicks(ImAxis axis, double vMin, double vMax, int nTicks, string[] labels)
		{
			byte** pStrArray0 = null;
			int pStrArray0Size = Utils.GetByteCountArray(labels);
			if (labels != null)
			{
				if (pStrArray0Size > Utils.MaxStackallocSize)
				{
					pStrArray0 = (byte**)Utils.Alloc<byte>(pStrArray0Size);
				}
				else
				{
					byte* pStrArray0Stack = stackalloc byte[pStrArray0Size];
					pStrArray0 = (byte**)pStrArray0Stack;
				}
			}
			for (int i = 0; i < labels.Length; i++)
			{
				pStrArray0[i] = (byte*)Utils.StringToUTF8Ptr(labels[i]);
			}
			SetupAxisTicksNative(axis, vMin, vMax, nTicks, pStrArray0, (byte)(0));
			for (int i = 0; i < labels.Length; i++)
			{
				Utils.Free(pStrArray0[i]);
			}
			if (pStrArray0Size >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStrArray0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SetupAxisScaleNative(ImAxis axis, ImPlotScale scale)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImAxis, ImPlotScale, void>)funcTable[40])(axis, scale);
			#else
			((delegate* unmanaged[Cdecl]<ImAxis, ImPlotScale, void>)funcTable[40])(axis, scale);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxisScale(ImAxis axis, ImPlotScale scale)
		{
			SetupAxisScaleNative(axis, scale);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SetupAxisScaleNative(ImAxis axis, ImPlotTransform forward, ImPlotTransform inverse, void* data)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImAxis, delegate*<double, void*, double>, delegate*<double, void*, double>, void*, void>)funcTable[41])(axis, (delegate*<double, void*, double>)Utils.GetFunctionPointerForDelegate(forward), (delegate*<double, void*, double>)Utils.GetFunctionPointerForDelegate(inverse), data);
			#else
			((delegate* unmanaged[Cdecl]<ImAxis, nint, nint, nint, void>)funcTable[41])(axis, (nint)Utils.GetFunctionPointerForDelegate(forward), (nint)Utils.GetFunctionPointerForDelegate(inverse), (nint)data);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxisScale(ImAxis axis, ImPlotTransform forward, ImPlotTransform inverse, void* data)
		{
			SetupAxisScaleNative(axis, forward, inverse, data);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxisScale(ImAxis axis, ImPlotTransform forward, ImPlotTransform inverse)
		{
			SetupAxisScaleNative(axis, forward, inverse, (void*)(((void*)0)));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SetupAxisLimitsConstraintsNative(ImAxis axis, double vMin, double vMax)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImAxis, double, double, void>)funcTable[42])(axis, vMin, vMax);
			#else
			((delegate* unmanaged[Cdecl]<ImAxis, double, double, void>)funcTable[42])(axis, vMin, vMax);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxisLimitsConstraints(ImAxis axis, double vMin, double vMax)
		{
			SetupAxisLimitsConstraintsNative(axis, vMin, vMax);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SetupAxisZoomConstraintsNative(ImAxis axis, double zMin, double zMax)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImAxis, double, double, void>)funcTable[43])(axis, zMin, zMax);
			#else
			((delegate* unmanaged[Cdecl]<ImAxis, double, double, void>)funcTable[43])(axis, zMin, zMax);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxisZoomConstraints(ImAxis axis, double zMin, double zMax)
		{
			SetupAxisZoomConstraintsNative(axis, zMin, zMax);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SetupAxesNative(byte* xLabel, byte* yLabel, ImPlotAxisFlags xFlags, ImPlotAxisFlags yFlags)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<byte*, byte*, ImPlotAxisFlags, ImPlotAxisFlags, void>)funcTable[44])(xLabel, yLabel, xFlags, yFlags);
			#else
			((delegate* unmanaged[Cdecl]<nint, nint, ImPlotAxisFlags, ImPlotAxisFlags, void>)funcTable[44])((nint)xLabel, (nint)yLabel, xFlags, yFlags);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(byte* xLabel, byte* yLabel, ImPlotAxisFlags xFlags, ImPlotAxisFlags yFlags)
		{
			SetupAxesNative(xLabel, yLabel, xFlags, yFlags);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(byte* xLabel, byte* yLabel, ImPlotAxisFlags xFlags)
		{
			SetupAxesNative(xLabel, yLabel, xFlags, (ImPlotAxisFlags)(0));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(byte* xLabel, byte* yLabel)
		{
			SetupAxesNative(xLabel, yLabel, (ImPlotAxisFlags)(0), (ImPlotAxisFlags)(0));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(ref byte xLabel, byte* yLabel, ImPlotAxisFlags xFlags, ImPlotAxisFlags yFlags)
		{
			fixed (byte* pxLabel = &xLabel)
			{
				SetupAxesNative((byte*)pxLabel, yLabel, xFlags, yFlags);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(ref byte xLabel, byte* yLabel, ImPlotAxisFlags xFlags)
		{
			fixed (byte* pxLabel = &xLabel)
			{
				SetupAxesNative((byte*)pxLabel, yLabel, xFlags, (ImPlotAxisFlags)(0));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(ref byte xLabel, byte* yLabel)
		{
			fixed (byte* pxLabel = &xLabel)
			{
				SetupAxesNative((byte*)pxLabel, yLabel, (ImPlotAxisFlags)(0), (ImPlotAxisFlags)(0));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(ReadOnlySpan<byte> xLabel, byte* yLabel, ImPlotAxisFlags xFlags, ImPlotAxisFlags yFlags)
		{
			fixed (byte* pxLabel = xLabel)
			{
				SetupAxesNative((byte*)pxLabel, yLabel, xFlags, yFlags);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(ReadOnlySpan<byte> xLabel, byte* yLabel, ImPlotAxisFlags xFlags)
		{
			fixed (byte* pxLabel = xLabel)
			{
				SetupAxesNative((byte*)pxLabel, yLabel, xFlags, (ImPlotAxisFlags)(0));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(ReadOnlySpan<byte> xLabel, byte* yLabel)
		{
			fixed (byte* pxLabel = xLabel)
			{
				SetupAxesNative((byte*)pxLabel, yLabel, (ImPlotAxisFlags)(0), (ImPlotAxisFlags)(0));
			}
		}

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

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

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(byte* xLabel, ref byte yLabel, ImPlotAxisFlags xFlags, ImPlotAxisFlags yFlags)
		{
			fixed (byte* pyLabel = &yLabel)
			{
				SetupAxesNative(xLabel, (byte*)pyLabel, xFlags, yFlags);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(byte* xLabel, ref byte yLabel, ImPlotAxisFlags xFlags)
		{
			fixed (byte* pyLabel = &yLabel)
			{
				SetupAxesNative(xLabel, (byte*)pyLabel, xFlags, (ImPlotAxisFlags)(0));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(byte* xLabel, ref byte yLabel)
		{
			fixed (byte* pyLabel = &yLabel)
			{
				SetupAxesNative(xLabel, (byte*)pyLabel, (ImPlotAxisFlags)(0), (ImPlotAxisFlags)(0));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(byte* xLabel, ReadOnlySpan<byte> yLabel, ImPlotAxisFlags xFlags, ImPlotAxisFlags yFlags)
		{
			fixed (byte* pyLabel = yLabel)
			{
				SetupAxesNative(xLabel, (byte*)pyLabel, xFlags, yFlags);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(byte* xLabel, ReadOnlySpan<byte> yLabel, ImPlotAxisFlags xFlags)
		{
			fixed (byte* pyLabel = yLabel)
			{
				SetupAxesNative(xLabel, (byte*)pyLabel, xFlags, (ImPlotAxisFlags)(0));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(byte* xLabel, ReadOnlySpan<byte> yLabel)
		{
			fixed (byte* pyLabel = yLabel)
			{
				SetupAxesNative(xLabel, (byte*)pyLabel, (ImPlotAxisFlags)(0), (ImPlotAxisFlags)(0));
			}
		}

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

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

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(ref byte xLabel, ref byte yLabel, ImPlotAxisFlags xFlags, ImPlotAxisFlags yFlags)
		{
			fixed (byte* pxLabel = &xLabel)
			{
				fixed (byte* pyLabel = &yLabel)
				{
					SetupAxesNative((byte*)pxLabel, (byte*)pyLabel, xFlags, yFlags);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(ref byte xLabel, ref byte yLabel, ImPlotAxisFlags xFlags)
		{
			fixed (byte* pxLabel = &xLabel)
			{
				fixed (byte* pyLabel = &yLabel)
				{
					SetupAxesNative((byte*)pxLabel, (byte*)pyLabel, xFlags, (ImPlotAxisFlags)(0));
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(ref byte xLabel, ref byte yLabel)
		{
			fixed (byte* pxLabel = &xLabel)
			{
				fixed (byte* pyLabel = &yLabel)
				{
					SetupAxesNative((byte*)pxLabel, (byte*)pyLabel, (ImPlotAxisFlags)(0), (ImPlotAxisFlags)(0));
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(ReadOnlySpan<byte> xLabel, ReadOnlySpan<byte> yLabel, ImPlotAxisFlags xFlags, ImPlotAxisFlags yFlags)
		{
			fixed (byte* pxLabel = xLabel)
			{
				fixed (byte* pyLabel = yLabel)
				{
					SetupAxesNative((byte*)pxLabel, (byte*)pyLabel, xFlags, yFlags);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(ReadOnlySpan<byte> xLabel, ReadOnlySpan<byte> yLabel, ImPlotAxisFlags xFlags)
		{
			fixed (byte* pxLabel = xLabel)
			{
				fixed (byte* pyLabel = yLabel)
				{
					SetupAxesNative((byte*)pxLabel, (byte*)pyLabel, xFlags, (ImPlotAxisFlags)(0));
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(ReadOnlySpan<byte> xLabel, ReadOnlySpan<byte> yLabel)
		{
			fixed (byte* pxLabel = xLabel)
			{
				fixed (byte* pyLabel = yLabel)
				{
					SetupAxesNative((byte*)pxLabel, (byte*)pyLabel, (ImPlotAxisFlags)(0), (ImPlotAxisFlags)(0));
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(string xLabel, string yLabel, ImPlotAxisFlags xFlags, ImPlotAxisFlags yFlags)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (xLabel != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(xLabel);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(xLabel, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			byte* pStr1 = null;
			int pStrSize1 = 0;
			if (yLabel != null)
			{
				pStrSize1 = Utils.GetByteCountUTF8(yLabel);
				if (pStrSize1 >= Utils.MaxStackallocSize)
				{
					pStr1 = Utils.Alloc<byte>(pStrSize1 + 1);
				}
				else
				{
					byte* pStrStack1 = stackalloc byte[pStrSize1 + 1];
					pStr1 = pStrStack1;
				}
				int pStrOffset1 = Utils.EncodeStringUTF8(yLabel, pStr1, pStrSize1);
				pStr1[pStrOffset1] = 0;
			}
			SetupAxesNative(pStr0, pStr1, xFlags, yFlags);
			if (pStrSize1 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr1);
			}
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(string xLabel, string yLabel, ImPlotAxisFlags xFlags)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (xLabel != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(xLabel);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(xLabel, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			byte* pStr1 = null;
			int pStrSize1 = 0;
			if (yLabel != null)
			{
				pStrSize1 = Utils.GetByteCountUTF8(yLabel);
				if (pStrSize1 >= Utils.MaxStackallocSize)
				{
					pStr1 = Utils.Alloc<byte>(pStrSize1 + 1);
				}
				else
				{
					byte* pStrStack1 = stackalloc byte[pStrSize1 + 1];
					pStr1 = pStrStack1;
				}
				int pStrOffset1 = Utils.EncodeStringUTF8(yLabel, pStr1, pStrSize1);
				pStr1[pStrOffset1] = 0;
			}
			SetupAxesNative(pStr0, pStr1, xFlags, (ImPlotAxisFlags)(0));
			if (pStrSize1 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr1);
			}
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(string xLabel, string yLabel)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (xLabel != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(xLabel);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(xLabel, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			byte* pStr1 = null;
			int pStrSize1 = 0;
			if (yLabel != null)
			{
				pStrSize1 = Utils.GetByteCountUTF8(yLabel);
				if (pStrSize1 >= Utils.MaxStackallocSize)
				{
					pStr1 = Utils.Alloc<byte>(pStrSize1 + 1);
				}
				else
				{
					byte* pStrStack1 = stackalloc byte[pStrSize1 + 1];
					pStr1 = pStrStack1;
				}
				int pStrOffset1 = Utils.EncodeStringUTF8(yLabel, pStr1, pStrSize1);
				pStr1[pStrOffset1] = 0;
			}
			SetupAxesNative(pStr0, pStr1, (ImPlotAxisFlags)(0), (ImPlotAxisFlags)(0));
			if (pStrSize1 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr1);
			}
			if (pStrSize0 >= Utils.MaxStackallocSize)
			{
				Utils.Free(pStr0);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(ref byte xLabel, ReadOnlySpan<byte> yLabel, ImPlotAxisFlags xFlags, ImPlotAxisFlags yFlags)
		{
			fixed (byte* pxLabel = &xLabel)
			{
				fixed (byte* pyLabel = yLabel)
				{
					SetupAxesNative((byte*)pxLabel, (byte*)pyLabel, xFlags, yFlags);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(ref byte xLabel, ReadOnlySpan<byte> yLabel, ImPlotAxisFlags xFlags)
		{
			fixed (byte* pxLabel = &xLabel)
			{
				fixed (byte* pyLabel = yLabel)
				{
					SetupAxesNative((byte*)pxLabel, (byte*)pyLabel, xFlags, (ImPlotAxisFlags)(0));
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(ref byte xLabel, ReadOnlySpan<byte> yLabel)
		{
			fixed (byte* pxLabel = &xLabel)
			{
				fixed (byte* pyLabel = yLabel)
				{
					SetupAxesNative((byte*)pxLabel, (byte*)pyLabel, (ImPlotAxisFlags)(0), (ImPlotAxisFlags)(0));
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(ref byte xLabel, string yLabel, ImPlotAxisFlags xFlags, ImPlotAxisFlags yFlags)
		{
			fixed (byte* pxLabel = &xLabel)
			{
				byte* pStr0 = null;
				int pStrSize0 = 0;
				if (yLabel != null)
				{
					pStrSize0 = Utils.GetByteCountUTF8(yLabel);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
					}
					else
					{
						byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
						pStr0 = pStrStack0;
					}
					int pStrOffset0 = Utils.EncodeStringUTF8(yLabel, pStr0, pStrSize0);
					pStr0[pStrOffset0] = 0;
				}
				SetupAxesNative((byte*)pxLabel, pStr0, xFlags, yFlags);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(ref byte xLabel, string yLabel, ImPlotAxisFlags xFlags)
		{
			fixed (byte* pxLabel = &xLabel)
			{
				byte* pStr0 = null;
				int pStrSize0 = 0;
				if (yLabel != null)
				{
					pStrSize0 = Utils.GetByteCountUTF8(yLabel);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
					}
					else
					{
						byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
						pStr0 = pStrStack0;
					}
					int pStrOffset0 = Utils.EncodeStringUTF8(yLabel, pStr0, pStrSize0);
					pStr0[pStrOffset0] = 0;
				}
				SetupAxesNative((byte*)pxLabel, pStr0, xFlags, (ImPlotAxisFlags)(0));
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(ref byte xLabel, string yLabel)
		{
			fixed (byte* pxLabel = &xLabel)
			{
				byte* pStr0 = null;
				int pStrSize0 = 0;
				if (yLabel != null)
				{
					pStrSize0 = Utils.GetByteCountUTF8(yLabel);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
					}
					else
					{
						byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
						pStr0 = pStrStack0;
					}
					int pStrOffset0 = Utils.EncodeStringUTF8(yLabel, pStr0, pStrSize0);
					pStr0[pStrOffset0] = 0;
				}
				SetupAxesNative((byte*)pxLabel, pStr0, (ImPlotAxisFlags)(0), (ImPlotAxisFlags)(0));
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(ReadOnlySpan<byte> xLabel, ref byte yLabel, ImPlotAxisFlags xFlags, ImPlotAxisFlags yFlags)
		{
			fixed (byte* pxLabel = xLabel)
			{
				fixed (byte* pyLabel = &yLabel)
				{
					SetupAxesNative((byte*)pxLabel, (byte*)pyLabel, xFlags, yFlags);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(ReadOnlySpan<byte> xLabel, ref byte yLabel, ImPlotAxisFlags xFlags)
		{
			fixed (byte* pxLabel = xLabel)
			{
				fixed (byte* pyLabel = &yLabel)
				{
					SetupAxesNative((byte*)pxLabel, (byte*)pyLabel, xFlags, (ImPlotAxisFlags)(0));
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(ReadOnlySpan<byte> xLabel, ref byte yLabel)
		{
			fixed (byte* pxLabel = xLabel)
			{
				fixed (byte* pyLabel = &yLabel)
				{
					SetupAxesNative((byte*)pxLabel, (byte*)pyLabel, (ImPlotAxisFlags)(0), (ImPlotAxisFlags)(0));
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(ReadOnlySpan<byte> xLabel, string yLabel, ImPlotAxisFlags xFlags, ImPlotAxisFlags yFlags)
		{
			fixed (byte* pxLabel = xLabel)
			{
				byte* pStr0 = null;
				int pStrSize0 = 0;
				if (yLabel != null)
				{
					pStrSize0 = Utils.GetByteCountUTF8(yLabel);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
					}
					else
					{
						byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
						pStr0 = pStrStack0;
					}
					int pStrOffset0 = Utils.EncodeStringUTF8(yLabel, pStr0, pStrSize0);
					pStr0[pStrOffset0] = 0;
				}
				SetupAxesNative((byte*)pxLabel, pStr0, xFlags, yFlags);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(ReadOnlySpan<byte> xLabel, string yLabel, ImPlotAxisFlags xFlags)
		{
			fixed (byte* pxLabel = xLabel)
			{
				byte* pStr0 = null;
				int pStrSize0 = 0;
				if (yLabel != null)
				{
					pStrSize0 = Utils.GetByteCountUTF8(yLabel);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
					}
					else
					{
						byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
						pStr0 = pStrStack0;
					}
					int pStrOffset0 = Utils.EncodeStringUTF8(yLabel, pStr0, pStrSize0);
					pStr0[pStrOffset0] = 0;
				}
				SetupAxesNative((byte*)pxLabel, pStr0, xFlags, (ImPlotAxisFlags)(0));
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(ReadOnlySpan<byte> xLabel, string yLabel)
		{
			fixed (byte* pxLabel = xLabel)
			{
				byte* pStr0 = null;
				int pStrSize0 = 0;
				if (yLabel != null)
				{
					pStrSize0 = Utils.GetByteCountUTF8(yLabel);
					if (pStrSize0 >= Utils.MaxStackallocSize)
					{
						pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
					}
					else
					{
						byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
						pStr0 = pStrStack0;
					}
					int pStrOffset0 = Utils.EncodeStringUTF8(yLabel, pStr0, pStrSize0);
					pStr0[pStrOffset0] = 0;
				}
				SetupAxesNative((byte*)pxLabel, pStr0, (ImPlotAxisFlags)(0), (ImPlotAxisFlags)(0));
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(string xLabel, ref byte yLabel, ImPlotAxisFlags xFlags, ImPlotAxisFlags yFlags)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (xLabel != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(xLabel);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(xLabel, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (byte* pyLabel = &yLabel)
			{
				SetupAxesNative(pStr0, (byte*)pyLabel, xFlags, yFlags);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(string xLabel, ref byte yLabel, ImPlotAxisFlags xFlags)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (xLabel != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(xLabel);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(xLabel, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (byte* pyLabel = &yLabel)
			{
				SetupAxesNative(pStr0, (byte*)pyLabel, xFlags, (ImPlotAxisFlags)(0));
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(string xLabel, ref byte yLabel)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (xLabel != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(xLabel);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(xLabel, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (byte* pyLabel = &yLabel)
			{
				SetupAxesNative(pStr0, (byte*)pyLabel, (ImPlotAxisFlags)(0), (ImPlotAxisFlags)(0));
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(string xLabel, ReadOnlySpan<byte> yLabel, ImPlotAxisFlags xFlags, ImPlotAxisFlags yFlags)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (xLabel != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(xLabel);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(xLabel, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (byte* pyLabel = yLabel)
			{
				SetupAxesNative(pStr0, (byte*)pyLabel, xFlags, yFlags);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(string xLabel, ReadOnlySpan<byte> yLabel, ImPlotAxisFlags xFlags)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (xLabel != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(xLabel);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(xLabel, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (byte* pyLabel = yLabel)
			{
				SetupAxesNative(pStr0, (byte*)pyLabel, xFlags, (ImPlotAxisFlags)(0));
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxes(string xLabel, ReadOnlySpan<byte> yLabel)
		{
			byte* pStr0 = null;
			int pStrSize0 = 0;
			if (xLabel != null)
			{
				pStrSize0 = Utils.GetByteCountUTF8(xLabel);
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
				}
				else
				{
					byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
					pStr0 = pStrStack0;
				}
				int pStrOffset0 = Utils.EncodeStringUTF8(xLabel, pStr0, pStrSize0);
				pStr0[pStrOffset0] = 0;
			}
			fixed (byte* pyLabel = yLabel)
			{
				SetupAxesNative(pStr0, (byte*)pyLabel, (ImPlotAxisFlags)(0), (ImPlotAxisFlags)(0));
				if (pStrSize0 >= Utils.MaxStackallocSize)
				{
					Utils.Free(pStr0);
				}
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SetupAxesLimitsNative(double xMin, double xMax, double yMin, double yMax, ImPlotCond cond)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<double, double, double, double, ImPlotCond, void>)funcTable[45])(xMin, xMax, yMin, yMax, cond);
			#else
			((delegate* unmanaged[Cdecl]<double, double, double, double, ImPlotCond, void>)funcTable[45])(xMin, xMax, yMin, yMax, cond);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxesLimits(double xMin, double xMax, double yMin, double yMax, ImPlotCond cond)
		{
			SetupAxesLimitsNative(xMin, xMax, yMin, yMax, cond);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupAxesLimits(double xMin, double xMax, double yMin, double yMax)
		{
			SetupAxesLimitsNative(xMin, xMax, yMin, yMax, (ImPlotCond)(ImPlotCond.Once));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SetupLegendNative(ImPlotLocation location, ImPlotLegendFlags flags)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImPlotLocation, ImPlotLegendFlags, void>)funcTable[46])(location, flags);
			#else
			((delegate* unmanaged[Cdecl]<ImPlotLocation, ImPlotLegendFlags, void>)funcTable[46])(location, flags);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupLegend(ImPlotLocation location, ImPlotLegendFlags flags)
		{
			SetupLegendNative(location, flags);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupLegend(ImPlotLocation location)
		{
			SetupLegendNative(location, (ImPlotLegendFlags)(0));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SetupMouseTextNative(ImPlotLocation location, ImPlotMouseTextFlags flags)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImPlotLocation, ImPlotMouseTextFlags, void>)funcTable[47])(location, flags);
			#else
			((delegate* unmanaged[Cdecl]<ImPlotLocation, ImPlotMouseTextFlags, void>)funcTable[47])(location, flags);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupMouseText(ImPlotLocation location, ImPlotMouseTextFlags flags)
		{
			SetupMouseTextNative(location, flags);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetupMouseText(ImPlotLocation location)
		{
			SetupMouseTextNative(location, (ImPlotMouseTextFlags)(0));
		}

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

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

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SetNextAxisLimitsNative(ImAxis axis, double vMin, double vMax, ImPlotCond cond)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImAxis, double, double, ImPlotCond, void>)funcTable[49])(axis, vMin, vMax, cond);
			#else
			((delegate* unmanaged[Cdecl]<ImAxis, double, double, ImPlotCond, void>)funcTable[49])(axis, vMin, vMax, cond);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetNextAxisLimits(ImAxis axis, double vMin, double vMax, ImPlotCond cond)
		{
			SetNextAxisLimitsNative(axis, vMin, vMax, cond);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetNextAxisLimits(ImAxis axis, double vMin, double vMax)
		{
			SetNextAxisLimitsNative(axis, vMin, vMax, (ImPlotCond)(ImPlotCond.Once));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SetNextAxisLinksNative(ImAxis axis, double* linkMin, double* linkMax)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<ImAxis, double*, double*, void>)funcTable[50])(axis, linkMin, linkMax);
			#else
			((delegate* unmanaged[Cdecl]<ImAxis, nint, nint, void>)funcTable[50])(axis, (nint)linkMin, (nint)linkMax);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetNextAxisLinks(ImAxis axis, double* linkMin, double* linkMax)
		{
			SetNextAxisLinksNative(axis, linkMin, linkMax);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetNextAxisLinks(ImAxis axis, ref double linkMin, double* linkMax)
		{
			fixed (double* plinkMin = &linkMin)
			{
				SetNextAxisLinksNative(axis, (double*)plinkMin, linkMax);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetNextAxisLinks(ImAxis axis, double* linkMin, ref double linkMax)
		{
			fixed (double* plinkMax = &linkMax)
			{
				SetNextAxisLinksNative(axis, linkMin, (double*)plinkMax);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetNextAxisLinks(ImAxis axis, ref double linkMin, ref double linkMax)
		{
			fixed (double* plinkMin = &linkMin)
			{
				fixed (double* plinkMax = &linkMax)
				{
					SetNextAxisLinksNative(axis, (double*)plinkMin, (double*)plinkMax);
				}
			}
		}

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

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetNextAxisToFit(ImAxis axis)
		{
			SetNextAxisToFitNative(axis);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void SetNextAxesLimitsNative(double xMin, double xMax, double yMin, double yMax, ImPlotCond cond)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<double, double, double, double, ImPlotCond, void>)funcTable[52])(xMin, xMax, yMin, yMax, cond);
			#else
			((delegate* unmanaged[Cdecl]<double, double, double, double, ImPlotCond, void>)funcTable[52])(xMin, xMax, yMin, yMax, cond);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetNextAxesLimits(double xMin, double xMax, double yMin, double yMax, ImPlotCond cond)
		{
			SetNextAxesLimitsNative(xMin, xMax, yMin, yMax, cond);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void SetNextAxesLimits(double xMin, double xMax, double yMin, double yMax)
		{
			SetNextAxesLimitsNative(xMin, xMax, yMin, yMax, (ImPlotCond)(ImPlotCond.Once));
		}

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

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

		/// <summary>
		/// To be documented.
		/// </summary>
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void PlotLineNative(byte* labelId, float* values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset, int stride)
		{
			#if NET5_0_OR_GREATER
			((delegate* unmanaged[Cdecl]<byte*, float*, int, double, double, ImPlotLineFlags, int, int, void>)funcTable[54])(labelId, values, count, xscale, xstart, flags, offset, stride);
			#else
			((delegate* unmanaged[Cdecl]<nint, nint, int, double, double, ImPlotLineFlags, int, int, void>)funcTable[54])((nint)labelId, (nint)values, count, xscale, xstart, flags, offset, stride);
			#endif
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(byte* labelId, float* values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset, int stride)
		{
			PlotLineNative(labelId, values, count, xscale, xstart, flags, offset, stride);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(byte* labelId, float* values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset)
		{
			PlotLineNative(labelId, values, count, xscale, xstart, flags, offset, (int)(sizeof(float)));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(byte* labelId, float* values, int count, double xscale, double xstart, ImPlotLineFlags flags)
		{
			PlotLineNative(labelId, values, count, xscale, xstart, flags, (int)(0), (int)(sizeof(float)));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(byte* labelId, float* values, int count, double xscale, double xstart)
		{
			PlotLineNative(labelId, values, count, xscale, xstart, (ImPlotLineFlags)(0), (int)(0), (int)(sizeof(float)));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(byte* labelId, float* values, int count, double xscale)
		{
			PlotLineNative(labelId, values, count, xscale, (double)(0), (ImPlotLineFlags)(0), (int)(0), (int)(sizeof(float)));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(byte* labelId, float* values, int count)
		{
			PlotLineNative(labelId, values, count, (double)(1), (double)(0), (ImPlotLineFlags)(0), (int)(0), (int)(sizeof(float)));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(byte* labelId, float* values, int count, double xscale, ImPlotLineFlags flags)
		{
			PlotLineNative(labelId, values, count, xscale, (double)(0), flags, (int)(0), (int)(sizeof(float)));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(byte* labelId, float* values, int count, ImPlotLineFlags flags)
		{
			PlotLineNative(labelId, values, count, (double)(1), (double)(0), flags, (int)(0), (int)(sizeof(float)));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(byte* labelId, float* values, int count, double xscale, double xstart, int offset)
		{
			PlotLineNative(labelId, values, count, xscale, xstart, (ImPlotLineFlags)(0), offset, (int)(sizeof(float)));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(byte* labelId, float* values, int count, double xscale, int offset)
		{
			PlotLineNative(labelId, values, count, xscale, (double)(0), (ImPlotLineFlags)(0), offset, (int)(sizeof(float)));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(byte* labelId, float* values, int count, int offset)
		{
			PlotLineNative(labelId, values, count, (double)(1), (double)(0), (ImPlotLineFlags)(0), offset, (int)(sizeof(float)));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(byte* labelId, float* values, int count, double xscale, ImPlotLineFlags flags, int offset)
		{
			PlotLineNative(labelId, values, count, xscale, (double)(0), flags, offset, (int)(sizeof(float)));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(byte* labelId, float* values, int count, ImPlotLineFlags flags, int offset)
		{
			PlotLineNative(labelId, values, count, (double)(1), (double)(0), flags, offset, (int)(sizeof(float)));
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(byte* labelId, float* values, int count, double xscale, double xstart, int offset, int stride)
		{
			PlotLineNative(labelId, values, count, xscale, xstart, (ImPlotLineFlags)(0), offset, stride);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(byte* labelId, float* values, int count, double xscale, int offset, int stride)
		{
			PlotLineNative(labelId, values, count, xscale, (double)(0), (ImPlotLineFlags)(0), offset, stride);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(byte* labelId, float* values, int count, int offset, int stride)
		{
			PlotLineNative(labelId, values, count, (double)(1), (double)(0), (ImPlotLineFlags)(0), offset, stride);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(byte* labelId, float* values, int count, double xscale, ImPlotLineFlags flags, int offset, int stride)
		{
			PlotLineNative(labelId, values, count, xscale, (double)(0), flags, offset, stride);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(byte* labelId, float* values, int count, ImPlotLineFlags flags, int offset, int stride)
		{
			PlotLineNative(labelId, values, count, (double)(1), (double)(0), flags, offset, stride);
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(ref byte labelId, float* values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset, int stride)
		{
			fixed (byte* plabelId = &labelId)
			{
				PlotLineNative((byte*)plabelId, values, count, xscale, xstart, flags, offset, stride);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(ref byte labelId, float* values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset)
		{
			fixed (byte* plabelId = &labelId)
			{
				PlotLineNative((byte*)plabelId, values, count, xscale, xstart, flags, offset, (int)(sizeof(float)));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(ref byte labelId, float* values, int count, double xscale, double xstart, ImPlotLineFlags flags)
		{
			fixed (byte* plabelId = &labelId)
			{
				PlotLineNative((byte*)plabelId, values, count, xscale, xstart, flags, (int)(0), (int)(sizeof(float)));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(ref byte labelId, float* values, int count, double xscale, double xstart)
		{
			fixed (byte* plabelId = &labelId)
			{
				PlotLineNative((byte*)plabelId, values, count, xscale, xstart, (ImPlotLineFlags)(0), (int)(0), (int)(sizeof(float)));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(ref byte labelId, float* values, int count, double xscale)
		{
			fixed (byte* plabelId = &labelId)
			{
				PlotLineNative((byte*)plabelId, values, count, xscale, (double)(0), (ImPlotLineFlags)(0), (int)(0), (int)(sizeof(float)));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(ref byte labelId, float* values, int count)
		{
			fixed (byte* plabelId = &labelId)
			{
				PlotLineNative((byte*)plabelId, values, count, (double)(1), (double)(0), (ImPlotLineFlags)(0), (int)(0), (int)(sizeof(float)));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(ref byte labelId, float* values, int count, double xscale, ImPlotLineFlags flags)
		{
			fixed (byte* plabelId = &labelId)
			{
				PlotLineNative((byte*)plabelId, values, count, xscale, (double)(0), flags, (int)(0), (int)(sizeof(float)));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(ref byte labelId, float* values, int count, ImPlotLineFlags flags)
		{
			fixed (byte* plabelId = &labelId)
			{
				PlotLineNative((byte*)plabelId, values, count, (double)(1), (double)(0), flags, (int)(0), (int)(sizeof(float)));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(ref byte labelId, float* values, int count, double xscale, double xstart, int offset)
		{
			fixed (byte* plabelId = &labelId)
			{
				PlotLineNative((byte*)plabelId, values, count, xscale, xstart, (ImPlotLineFlags)(0), offset, (int)(sizeof(float)));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(ref byte labelId, float* values, int count, double xscale, int offset)
		{
			fixed (byte* plabelId = &labelId)
			{
				PlotLineNative((byte*)plabelId, values, count, xscale, (double)(0), (ImPlotLineFlags)(0), offset, (int)(sizeof(float)));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(ref byte labelId, float* values, int count, int offset)
		{
			fixed (byte* plabelId = &labelId)
			{
				PlotLineNative((byte*)plabelId, values, count, (double)(1), (double)(0), (ImPlotLineFlags)(0), offset, (int)(sizeof(float)));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(ref byte labelId, float* values, int count, double xscale, ImPlotLineFlags flags, int offset)
		{
			fixed (byte* plabelId = &labelId)
			{
				PlotLineNative((byte*)plabelId, values, count, xscale, (double)(0), flags, offset, (int)(sizeof(float)));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(ref byte labelId, float* values, int count, ImPlotLineFlags flags, int offset)
		{
			fixed (byte* plabelId = &labelId)
			{
				PlotLineNative((byte*)plabelId, values, count, (double)(1), (double)(0), flags, offset, (int)(sizeof(float)));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(ref byte labelId, float* values, int count, double xscale, double xstart, int offset, int stride)
		{
			fixed (byte* plabelId = &labelId)
			{
				PlotLineNative((byte*)plabelId, values, count, xscale, xstart, (ImPlotLineFlags)(0), offset, stride);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(ref byte labelId, float* values, int count, double xscale, int offset, int stride)
		{
			fixed (byte* plabelId = &labelId)
			{
				PlotLineNative((byte*)plabelId, values, count, xscale, (double)(0), (ImPlotLineFlags)(0), offset, stride);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(ref byte labelId, float* values, int count, int offset, int stride)
		{
			fixed (byte* plabelId = &labelId)
			{
				PlotLineNative((byte*)plabelId, values, count, (double)(1), (double)(0), (ImPlotLineFlags)(0), offset, stride);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(ref byte labelId, float* values, int count, double xscale, ImPlotLineFlags flags, int offset, int stride)
		{
			fixed (byte* plabelId = &labelId)
			{
				PlotLineNative((byte*)plabelId, values, count, xscale, (double)(0), flags, offset, stride);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(ref byte labelId, float* values, int count, ImPlotLineFlags flags, int offset, int stride)
		{
			fixed (byte* plabelId = &labelId)
			{
				PlotLineNative((byte*)plabelId, values, count, (double)(1), (double)(0), flags, offset, stride);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(ReadOnlySpan<byte> labelId, float* values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset, int stride)
		{
			fixed (byte* plabelId = labelId)
			{
				PlotLineNative((byte*)plabelId, values, count, xscale, xstart, flags, offset, stride);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(ReadOnlySpan<byte> labelId, float* values, int count, double xscale, double xstart, ImPlotLineFlags flags, int offset)
		{
			fixed (byte* plabelId = labelId)
			{
				PlotLineNative((byte*)plabelId, values, count, xscale, xstart, flags, offset, (int)(sizeof(float)));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(ReadOnlySpan<byte> labelId, float* values, int count, double xscale, double xstart, ImPlotLineFlags flags)
		{
			fixed (byte* plabelId = labelId)
			{
				PlotLineNative((byte*)plabelId, values, count, xscale, xstart, flags, (int)(0), (int)(sizeof(float)));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(ReadOnlySpan<byte> labelId, float* values, int count, double xscale, double xstart)
		{
			fixed (byte* plabelId = labelId)
			{
				PlotLineNative((byte*)plabelId, values, count, xscale, xstart, (ImPlotLineFlags)(0), (int)(0), (int)(sizeof(float)));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(ReadOnlySpan<byte> labelId, float* values, int count, double xscale)
		{
			fixed (byte* plabelId = labelId)
			{
				PlotLineNative((byte*)plabelId, values, count, xscale, (double)(0), (ImPlotLineFlags)(0), (int)(0), (int)(sizeof(float)));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(ReadOnlySpan<byte> labelId, float* values, int count)
		{
			fixed (byte* plabelId = labelId)
			{
				PlotLineNative((byte*)plabelId, values, count, (double)(1), (double)(0), (ImPlotLineFlags)(0), (int)(0), (int)(sizeof(float)));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(ReadOnlySpan<byte> labelId, float* values, int count, double xscale, ImPlotLineFlags flags)
		{
			fixed (byte* plabelId = labelId)
			{
				PlotLineNative((byte*)plabelId, values, count, xscale, (double)(0), flags, (int)(0), (int)(sizeof(float)));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(ReadOnlySpan<byte> labelId, float* values, int count, ImPlotLineFlags flags)
		{
			fixed (byte* plabelId = labelId)
			{
				PlotLineNative((byte*)plabelId, values, count, (double)(1), (double)(0), flags, (int)(0), (int)(sizeof(float)));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(ReadOnlySpan<byte> labelId, float* values, int count, double xscale, double xstart, int offset)
		{
			fixed (byte* plabelId = labelId)
			{
				PlotLineNative((byte*)plabelId, values, count, xscale, xstart, (ImPlotLineFlags)(0), offset, (int)(sizeof(float)));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(ReadOnlySpan<byte> labelId, float* values, int count, double xscale, int offset)
		{
			fixed (byte* plabelId = labelId)
			{
				PlotLineNative((byte*)plabelId, values, count, xscale, (double)(0), (ImPlotLineFlags)(0), offset, (int)(sizeof(float)));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(ReadOnlySpan<byte> labelId, float* values, int count, int offset)
		{
			fixed (byte* plabelId = labelId)
			{
				PlotLineNative((byte*)plabelId, values, count, (double)(1), (double)(0), (ImPlotLineFlags)(0), offset, (int)(sizeof(float)));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(ReadOnlySpan<byte> labelId, float* values, int count, double xscale, ImPlotLineFlags flags, int offset)
		{
			fixed (byte* plabelId = labelId)
			{
				PlotLineNative((byte*)plabelId, values, count, xscale, (double)(0), flags, offset, (int)(sizeof(float)));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(ReadOnlySpan<byte> labelId, float* values, int count, ImPlotLineFlags flags, int offset)
		{
			fixed (byte* plabelId = labelId)
			{
				PlotLineNative((byte*)plabelId, values, count, (double)(1), (double)(0), flags, offset, (int)(sizeof(float)));
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(ReadOnlySpan<byte> labelId, float* values, int count, double xscale, double xstart, int offset, int stride)
		{
			fixed (byte* plabelId = labelId)
			{
				PlotLineNative((byte*)plabelId, values, count, xscale, xstart, (ImPlotLineFlags)(0), offset, stride);
			}
		}

		/// <summary>
		/// To be documented.
		/// </summary>
		public static void PlotLine(ReadOnlySpan<byte> labelId, float* values, int count, double xscale, int offset, int stride)
		{
			fixed (byte* plabelId = labelId)
			{
				PlotLineNative((byte*)plabelId, values, count, xscale, (double)(0), (ImPlotLineFlags)(0), offset, stride);
			}
		}
	}
}